aidl_typenames.cpp - platform/system/tools/aidl - Git at Google

 /*
  * Copyright (C) 2018, The Android Open Source Project
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
  *     http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */

 #include "aidl_typenames.h"
 #include "aidl_language.h"
 #include "logging.h"

 #include <android-base/strings.h>

 #include <map>
 #include <memory>
 #include <set>
 #include <string>
 #include <utility>
 #include <vector>

 using android::base::Split;

 using std::make_pair;
 using std::map;
 using std::pair;
 using std::set;
 using std::string;
 using std::unique_ptr;
 using std::vector;

 namespace android {
 namespace aidl {

 // The built-in AIDL types..
 static const set<string> kBuiltinTypes = {"void",
                                           "boolean",
                                           "byte",
                                           "char",
                                           "int",
                                           "long",
                                           "float",
                                           "double",
                                           "String",
                                           "List",
                                           "Map",
                                           "IBinder",
                                           "FileDescriptor",
                                           "CharSequence",
                                           "ParcelFileDescriptor",
                                           "ParcelableHolder"};

 static const set<string> kPrimitiveTypes = {"void", "boolean", "byte",  "char",
                                             "int",  "long",    "float", "double"};

 // Note: these types may look wrong because they look like Java
 // types, but they have long been supported from the time when Java
 // was the only target language of this compiler. They are added here for
 // backwards compatibility, but we internally treat them as List and Map,
 // respectively.
 static const map<string, string> kJavaLikeTypeToAidlType = {
     {"java.util.List", "List"},
     {"java.util.Map", "Map"},
     {"android.os.ParcelFileDescriptor", "ParcelFileDescriptor"},
 };

 // Package name and type name can't be one of these as they are keywords
 // in Java and C++. Using these names will eventually cause compilation error,
 // so checking this here is not a must have, but early detection of errors
 // is always better.
 static const set<string> kCppOrJavaReservedWord = {
     "break",  "case",   "catch", "char",     "class",  "continue", "default",
     "do",     "double", "else",  "enum",     "false",  "float",    "for",
     "goto",   "if",     "int",   "long",     "new",    "private",  "protected",
     "public", "return", "short", "static",   "switch", "this",     "throw",
     "true",   "try",    "void",  "volatile", "while"};

 static bool HasValidNameComponents(const AidlDefinedType& defined) {
   bool success = true;
   vector<string> pieces = Split(defined.GetCanonicalName(), ".");
   for (const string& piece : pieces) {
     if (kCppOrJavaReservedWord.find(piece) != kCppOrJavaReservedWord.end()) {
       AIDL_ERROR(defined) << defined.GetCanonicalName() << " is an invalid name because '" << piece
                           << "' is a Java or C++ identifier.";
       success = false;
     }
     // not checking kJavaLikeTypeToAidl, since that wouldn't make sense here
     if (kBuiltinTypes.find(piece) != kBuiltinTypes.end()) {
       AIDL_ERROR(defined) << defined.GetCanonicalName() << " is an invalid name because '" << piece
                           << "' is a built-in AIDL type.";
       success = false;
     }
   }
   return success;
 }

 bool AidlTypenames::IsIgnorableImport(const string& import) const {
   static set<string> ignore_import = {
       "android.os.IInterface",   "android.os.IBinder", "android.os.Parcelable", "android.os.Parcel",
       "android.content.Context", "java.lang.String",   "java.lang.CharSequence"};
   // these known built-in types don't need to be imported
   const bool in_ignore_import = ignore_import.find(import) != ignore_import.end();
   // an already defined type doesn't need to be imported again unless it is from
   // the preprocessed file
   auto ret = TryGetDefinedTypeImpl(import);
   const bool defined_type_not_from_preprocessed = ret.type != nullptr && !ret.from_preprocessed;
   return in_ignore_import || defined_type_not_from_preprocessed;
 }

 bool AidlTypenames::AddDocument(std::unique_ptr<AidlDocument> doc) {
   for (const auto& type : doc->DefinedTypes()) {
     if (defined_types_.find(type->GetCanonicalName()) != defined_types_.end()) {
       return false;
     }
     if (!HasValidNameComponents(*type)) {
       return false;
     }
   }
   documents_.push_back(std::move(doc));
   for (const auto& type : documents_.back()->DefinedTypes()) {
     defined_types_.emplace(type->GetCanonicalName(), type.get());
   }
   return true;
 }

 const AidlDocument* AidlTypenames::GetDocumentFor(const AidlDefinedType* type) const {
   for (const auto& doc : AllDocuments()) {
     for (const auto& defined_type : doc->DefinedTypes()) {
       if (defined_type.get() == type) {
         return doc.get();
       }
     }
   }
   return nullptr;
 }

 const AidlDocument& AidlTypenames::MainDocument() const {
   AIDL_FATAL_IF(documents_.size() == 0, AIDL_LOCATION_HERE) << "Main document doesn't exist";
   return *(documents_[0]);
 }

 bool AidlTypenames::AddPreprocessedType(unique_ptr<AidlDefinedType> type) {
   const string name = type->GetCanonicalName();
   if (preprocessed_types_.find(name) != preprocessed_types_.end()) {
     return false;
   }
   if (!HasValidNameComponents(*type)) {
     return false;
   }
   preprocessed_types_.insert(make_pair(name, std::move(type)));
   return true;
 }

 bool AidlTypenames::IsBuiltinTypename(const string& type_name) {
   return kBuiltinTypes.find(type_name) != kBuiltinTypes.end() ||
       kJavaLikeTypeToAidlType.find(type_name) != kJavaLikeTypeToAidlType.end();
 }

 bool AidlTypenames::IsPrimitiveTypename(const string& type_name) {
   return kPrimitiveTypes.find(type_name) != kPrimitiveTypes.end();
 }

 bool AidlTypenames::IsParcelable(const string& type_name) const {
   if (IsBuiltinTypename(type_name)) {
     return type_name == "ParcelableHolder" || type_name == "ParcelFileDescriptor";
   }
   if (auto defined_type = TryGetDefinedType(type_name); defined_type) {
     return defined_type->AsParcelable() != nullptr;
   }
   return false;
 }

 const AidlDefinedType* AidlTypenames::TryGetDefinedType(const string& type_name) const {
   return TryGetDefinedTypeImpl(type_name).type;
 }

 AidlTypenames::DefinedImplResult AidlTypenames::TryGetDefinedTypeImpl(
     const string& type_name) const {
   // Do the exact match first.
   auto found_def = defined_types_.find(type_name);
   if (found_def != defined_types_.end()) {
     return DefinedImplResult(found_def->second, false);
   }

   auto found_prep = preprocessed_types_.find(type_name);
   if (found_prep != preprocessed_types_.end()) {
     return DefinedImplResult(found_prep->second.get(), true);
   }

   // Then match with the class name. Defined types has higher priority than
   // types from the preprocessed file.
   for (auto it = defined_types_.begin(); it != defined_types_.end(); it++) {
     if (it->second->GetName() == type_name) {
       return DefinedImplResult(it->second, false);
     }
   }

   for (auto it = preprocessed_types_.begin(); it != preprocessed_types_.end(); it++) {
     if (it->second->GetName() == type_name) {
       return DefinedImplResult(it->second.get(), true);
     }
   }

   return DefinedImplResult(nullptr, false);
 }

 std::vector<AidlDefinedType*> AidlTypenames::AllDefinedTypes() const {
   std::vector<AidlDefinedType*> res;
   for (const auto& d : AllDocuments()) {
     for (const auto& t : d->DefinedTypes()) {
       res.push_back(t.get());
     }
   }
   return res;
 }

 AidlTypenames::ResolvedTypename AidlTypenames::ResolveTypename(const string& type_name) const {
   if (IsBuiltinTypename(type_name)) {
     auto found = kJavaLikeTypeToAidlType.find(type_name);
     if (found != kJavaLikeTypeToAidlType.end()) {
       return {found->second, true, nullptr};
     }
     return {type_name, true, nullptr};
   }
   const AidlDefinedType* defined_type = TryGetDefinedType(type_name);
   if (defined_type != nullptr) {
     return {defined_type->GetCanonicalName(), true, defined_type};
   } else {
     return {type_name, false, nullptr};
   }
 }

 // Only immutable Parcelable, primitive type, and String, and List, Map, array of the types can be
 // immutable.
 bool AidlTypenames::CanBeJavaOnlyImmutable(const AidlTypeSpecifier& type) const {
   const string& name = type.GetName();
   if (type.IsGeneric()) {
     if (type.GetName() == "List" || type.GetName() == "Map") {
       const auto& types = type.GetTypeParameters();
       return std::all_of(types.begin(), types.end(),
                          [this](const auto& t) { return CanBeJavaOnlyImmutable(*t); });
     }
     AIDL_ERROR(type) << "For a generic type, an immutable parcelable can contain only List or Map.";
     return false;
   }
   if (IsPrimitiveTypename(name) || name == "String") {
     return true;
   }
   const AidlDefinedType* t = TryGetDefinedType(type.GetName());
   if (t == nullptr) {
     AIDL_ERROR(type) << "An immutable parcelable can contain only immutable Parcelable, primitive "
                         "type, and String.";
     return false;
   }
   if (t->AsEnumDeclaration()) {
     return true;
   }
   return t->IsJavaOnlyImmutable();
 }

 // Only FixedSize Parcelable, primitive types, and enum types can be FixedSize.
 bool AidlTypenames::CanBeFixedSize(const AidlTypeSpecifier& type) const {
   const string& name = type.GetName();
   if (type.IsGeneric() || type.IsArray()) {
     return false;
   }
   if (IsPrimitiveTypename(name)) {
     return true;
   }
   if (IsBuiltinTypename(name)) {
     return false;
   }
   const AidlDefinedType* t = TryGetDefinedType(type.GetName());
   AIDL_FATAL_IF(t == nullptr, type)
       << "Failed to look up type. Cannot determine if it can be fixed size: " << type.GetName();

   if (t->AsEnumDeclaration()) {
     return true;
   }
   return t->IsFixedSize();
 }

 bool AidlTypenames::IsList(const AidlTypeSpecifier& type) {
   return type.GetName() == "List";
 }

 ArgumentAspect AidlTypenames::GetArgumentAspect(const AidlTypeSpecifier& type) const {
   if (type.IsArray()) {
     return {"array",
             {AidlArgument::Direction::IN_DIR, AidlArgument::Direction::OUT_DIR,
              AidlArgument::Direction::INOUT_DIR}};
   }
   const string& name = type.GetName();
   if (IsBuiltinTypename(name)) {
     if (name == "List" || name == "Map") {
       return {name,
               {AidlArgument::Direction::IN_DIR, AidlArgument::Direction::OUT_DIR,
                AidlArgument::Direction::INOUT_DIR}};
     } else if (name == "ParcelFileDescriptor") {
       // "out ParcelFileDescriptor" is not allowed because ParcelFileDescriptor is not
       // default-constructible.
       return {name, {AidlArgument::Direction::IN_DIR, AidlArgument::Direction::INOUT_DIR}};
     } else if (name == "ParcelableHolder") {
       // TODO(b/156872582): Support it when ParcelableHolder supports every backend.
       return {name, {}};
     } else {
       return {name, {AidlArgument::Direction::IN_DIR}};
     }
   }

   const AidlDefinedType* t = TryGetDefinedType(name);
   AIDL_FATAL_IF(t == nullptr, type) << "Unrecognized type: '" << name << "'";

   // An 'out' field is passed as an argument, so it doesn't make sense if it is immutable.
   if (t->AsParcelable() != nullptr) {
     if (t->IsJavaOnlyImmutable()) {
       return {"@JavaOnlyImmutable", {AidlArgument::Direction::IN_DIR}};
     }
     return {"parcelable/union",
             {AidlArgument::Direction::IN_DIR, AidlArgument::Direction::OUT_DIR,
              AidlArgument::Direction::INOUT_DIR}};
   }

   return {t->GetPreprocessDeclarationName(), {AidlArgument::Direction::IN_DIR}};
 }

 const AidlEnumDeclaration* AidlTypenames::GetEnumDeclaration(const AidlTypeSpecifier& type) const {
   if (auto defined_type = TryGetDefinedType(type.GetName()); defined_type != nullptr) {
     if (auto enum_decl = defined_type->AsEnumDeclaration(); enum_decl != nullptr) {
       return enum_decl;
     }
   }
   return nullptr;
 }

 const AidlInterface* AidlTypenames::GetInterface(const AidlTypeSpecifier& type) const {
   if (auto defined_type = TryGetDefinedType(type.GetName()); defined_type != nullptr) {
     if (auto intf = defined_type->AsInterface(); intf != nullptr) {
       return intf;
     }
   }
   return nullptr;
 }

 const AidlParcelable* AidlTypenames::GetParcelable(const AidlTypeSpecifier& type) const {
   if (auto defined_type = TryGetDefinedType(type.GetName()); defined_type != nullptr) {
     if (auto parcelable = defined_type->AsParcelable(); parcelable != nullptr) {
       return parcelable;
     }
   }
   return nullptr;
 }

 void AidlTypenames::IterateTypes(const std::function<void(const AidlDefinedType&)>& body) const {
   for (const auto& kv : defined_types_) {
     body(*kv.second);
   }
   for (const auto& kv : preprocessed_types_) {
     body(*kv.second);
   }
 }

 bool AidlTypenames::Autofill() const {
   bool success = true;
   IterateTypes([&](const AidlDefinedType& type) {
     // BackingType is filled in for all known enums, including imported enums,
     // because other types that may use enums, such as Interface or
     // StructuredParcelable, need to know the enum BackingType when
     // generating code.
     if (auto enum_decl = const_cast<AidlDefinedType&>(type).AsEnumDeclaration(); enum_decl) {
       if (!enum_decl->Autofill(*this)) {
         success = false;
       }
     }
   });
   return success;
 }

 }  // namespace aidl
 }  // namespace android
	/*
	* Copyright (C) 2018, The Android Open Source Project
	*
	* Licensed under the Apache License, Version 2.0 (the "License");
	* you may not use this file except in compliance with the License.
	* You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*/

	#include "aidl_typenames.h"
	#include "aidl_language.h"
	#include "logging.h"

	#include <android-base/strings.h>

	#include <map>
	#include <memory>
	#include <set>
	#include <string>
	#include <utility>
	#include <vector>

	using android::base::Split;

	using std::make_pair;
	using std::map;
	using std::pair;
	using std::set;
	using std::string;
	using std::unique_ptr;
	using std::vector;

	namespace android {
	namespace aidl {

	// The built-in AIDL types..
	static const set<string> kBuiltinTypes = {"void",
	"boolean",
	"byte",
	"char",
	"int",
	"long",
	"float",
	"double",
	"String",
	"List",
	"Map",
	"IBinder",
	"FileDescriptor",
	"CharSequence",
	"ParcelFileDescriptor",
	"ParcelableHolder"};

	static const set<string> kPrimitiveTypes = {"void", "boolean", "byte", "char",
	"int", "long", "float", "double"};

	// Note: these types may look wrong because they look like Java
	// types, but they have long been supported from the time when Java
	// was the only target language of this compiler. They are added here for
	// backwards compatibility, but we internally treat them as List and Map,
	// respectively.
	static const map<string, string> kJavaLikeTypeToAidlType = {
	{"java.util.List", "List"},
	{"java.util.Map", "Map"},
	{"android.os.ParcelFileDescriptor", "ParcelFileDescriptor"},
	};

	// Package name and type name can't be one of these as they are keywords
	// in Java and C++. Using these names will eventually cause compilation error,
	// so checking this here is not a must have, but early detection of errors
	// is always better.
	static const set<string> kCppOrJavaReservedWord = {
	"break", "case", "catch", "char", "class", "continue", "default",
	"do", "double", "else", "enum", "false", "float", "for",
	"goto", "if", "int", "long", "new", "private", "protected",
	"public", "return", "short", "static", "switch", "this", "throw",
	"true", "try", "void", "volatile", "while"};

	static bool HasValidNameComponents(const AidlDefinedType& defined) {
	bool success = true;
	vector<string> pieces = Split(defined.GetCanonicalName(), ".");
	for (const string& piece : pieces) {
	if (kCppOrJavaReservedWord.find(piece) != kCppOrJavaReservedWord.end()) {
	AIDL_ERROR(defined) << defined.GetCanonicalName() << " is an invalid name because '" << piece
	<< "' is a Java or C++ identifier.";
	success = false;
	}
	// not checking kJavaLikeTypeToAidl, since that wouldn't make sense here
	if (kBuiltinTypes.find(piece) != kBuiltinTypes.end()) {
	AIDL_ERROR(defined) << defined.GetCanonicalName() << " is an invalid name because '" << piece
	<< "' is a built-in AIDL type.";
	success = false;
	}
	}
	return success;
	}

	bool AidlTypenames::IsIgnorableImport(const string& import) const {
	static set<string> ignore_import = {
	"android.os.IInterface", "android.os.IBinder", "android.os.Parcelable", "android.os.Parcel",
	"android.content.Context", "java.lang.String", "java.lang.CharSequence"};
	// these known built-in types don't need to be imported
	const bool in_ignore_import = ignore_import.find(import) != ignore_import.end();
	// an already defined type doesn't need to be imported again unless it is from
	// the preprocessed file
	auto ret = TryGetDefinedTypeImpl(import);
	const bool defined_type_not_from_preprocessed = ret.type != nullptr && !ret.from_preprocessed;
	return in_ignore_import \|\| defined_type_not_from_preprocessed;
	}

	bool AidlTypenames::AddDocument(std::unique_ptr<AidlDocument> doc) {
	for (const auto& type : doc->DefinedTypes()) {
	if (defined_types_.find(type->GetCanonicalName()) != defined_types_.end()) {
	return false;
	}
	if (!HasValidNameComponents(*type)) {
	return false;
	}
	}
	documents_.push_back(std::move(doc));
	for (const auto& type : documents_.back()->DefinedTypes()) {
	defined_types_.emplace(type->GetCanonicalName(), type.get());
	}
	return true;
	}

	const AidlDocument* AidlTypenames::GetDocumentFor(const AidlDefinedType* type) const {
	for (const auto& doc : AllDocuments()) {
	for (const auto& defined_type : doc->DefinedTypes()) {
	if (defined_type.get() == type) {
	return doc.get();
	}
	}
	}
	return nullptr;
	}

	const AidlDocument& AidlTypenames::MainDocument() const {
	AIDL_FATAL_IF(documents_.size() == 0, AIDL_LOCATION_HERE) << "Main document doesn't exist";
	return *(documents_[0]);
	}

	bool AidlTypenames::AddPreprocessedType(unique_ptr<AidlDefinedType> type) {
	const string name = type->GetCanonicalName();
	if (preprocessed_types_.find(name) != preprocessed_types_.end()) {
	return false;
	}
	if (!HasValidNameComponents(*type)) {
	return false;
	}
	preprocessed_types_.insert(make_pair(name, std::move(type)));
	return true;
	}

	bool AidlTypenames::IsBuiltinTypename(const string& type_name) {
	return kBuiltinTypes.find(type_name) != kBuiltinTypes.end() \|\|
	kJavaLikeTypeToAidlType.find(type_name) != kJavaLikeTypeToAidlType.end();
	}

	bool AidlTypenames::IsPrimitiveTypename(const string& type_name) {
	return kPrimitiveTypes.find(type_name) != kPrimitiveTypes.end();
	}

	bool AidlTypenames::IsParcelable(const string& type_name) const {
	if (IsBuiltinTypename(type_name)) {
	return type_name == "ParcelableHolder" \|\| type_name == "ParcelFileDescriptor";
	}
	if (auto defined_type = TryGetDefinedType(type_name); defined_type) {
	return defined_type->AsParcelable() != nullptr;
	}
	return false;
	}

	const AidlDefinedType* AidlTypenames::TryGetDefinedType(const string& type_name) const {
	return TryGetDefinedTypeImpl(type_name).type;
	}

	AidlTypenames::DefinedImplResult AidlTypenames::TryGetDefinedTypeImpl(
	const string& type_name) const {
	// Do the exact match first.
	auto found_def = defined_types_.find(type_name);
	if (found_def != defined_types_.end()) {
	return DefinedImplResult(found_def->second, false);
	}

	auto found_prep = preprocessed_types_.find(type_name);
	if (found_prep != preprocessed_types_.end()) {
	return DefinedImplResult(found_prep->second.get(), true);
	}

	// Then match with the class name. Defined types has higher priority than
	// types from the preprocessed file.
	for (auto it = defined_types_.begin(); it != defined_types_.end(); it++) {
	if (it->second->GetName() == type_name) {
	return DefinedImplResult(it->second, false);
	}
	}

	for (auto it = preprocessed_types_.begin(); it != preprocessed_types_.end(); it++) {
	if (it->second->GetName() == type_name) {
	return DefinedImplResult(it->second.get(), true);
	}
	}

	return DefinedImplResult(nullptr, false);
	}

	std::vector<AidlDefinedType*> AidlTypenames::AllDefinedTypes() const {
	std::vector<AidlDefinedType*> res;
	for (const auto& d : AllDocuments()) {
	for (const auto& t : d->DefinedTypes()) {
	res.push_back(t.get());
	}
	}
	return res;
	}

	AidlTypenames::ResolvedTypename AidlTypenames::ResolveTypename(const string& type_name) const {
	if (IsBuiltinTypename(type_name)) {
	auto found = kJavaLikeTypeToAidlType.find(type_name);
	if (found != kJavaLikeTypeToAidlType.end()) {
	return {found->second, true, nullptr};
	}
	return {type_name, true, nullptr};
	}
	const AidlDefinedType* defined_type = TryGetDefinedType(type_name);
	if (defined_type != nullptr) {
	return {defined_type->GetCanonicalName(), true, defined_type};
	} else {
	return {type_name, false, nullptr};
	}
	}

	// Only immutable Parcelable, primitive type, and String, and List, Map, array of the types can be
	// immutable.
	bool AidlTypenames::CanBeJavaOnlyImmutable(const AidlTypeSpecifier& type) const {
	const string& name = type.GetName();
	if (type.IsGeneric()) {
	if (type.GetName() == "List" \|\| type.GetName() == "Map") {
	const auto& types = type.GetTypeParameters();
	return std::all_of(types.begin(), types.end(),
	[this](const auto& t) { return CanBeJavaOnlyImmutable(*t); });
	}
	AIDL_ERROR(type) << "For a generic type, an immutable parcelable can contain only List or Map.";
	return false;
	}
	if (IsPrimitiveTypename(name) \|\| name == "String") {
	return true;
	}
	const AidlDefinedType* t = TryGetDefinedType(type.GetName());
	if (t == nullptr) {
	AIDL_ERROR(type) << "An immutable parcelable can contain only immutable Parcelable, primitive "
	"type, and String.";
	return false;
	}
	if (t->AsEnumDeclaration()) {
	return true;
	}
	return t->IsJavaOnlyImmutable();
	}

	// Only FixedSize Parcelable, primitive types, and enum types can be FixedSize.
	bool AidlTypenames::CanBeFixedSize(const AidlTypeSpecifier& type) const {
	const string& name = type.GetName();
	if (type.IsGeneric() \|\| type.IsArray()) {
	return false;
	}
	if (IsPrimitiveTypename(name)) {
	return true;
	}
	if (IsBuiltinTypename(name)) {
	return false;
	}
	const AidlDefinedType* t = TryGetDefinedType(type.GetName());
	AIDL_FATAL_IF(t == nullptr, type)
	<< "Failed to look up type. Cannot determine if it can be fixed size: " << type.GetName();

	if (t->AsEnumDeclaration()) {
	return true;
	}
	return t->IsFixedSize();
	}

	bool AidlTypenames::IsList(const AidlTypeSpecifier& type) {
	return type.GetName() == "List";
	}

	ArgumentAspect AidlTypenames::GetArgumentAspect(const AidlTypeSpecifier& type) const {
	if (type.IsArray()) {
	return {"array",
	{AidlArgument::Direction::IN_DIR, AidlArgument::Direction::OUT_DIR,
	AidlArgument::Direction::INOUT_DIR}};
	}
	const string& name = type.GetName();
	if (IsBuiltinTypename(name)) {
	if (name == "List" \|\| name == "Map") {
	return {name,
	{AidlArgument::Direction::IN_DIR, AidlArgument::Direction::OUT_DIR,
	AidlArgument::Direction::INOUT_DIR}};
	} else if (name == "ParcelFileDescriptor") {
	// "out ParcelFileDescriptor" is not allowed because ParcelFileDescriptor is not
	// default-constructible.
	return {name, {AidlArgument::Direction::IN_DIR, AidlArgument::Direction::INOUT_DIR}};
	} else if (name == "ParcelableHolder") {
	// TODO(b/156872582): Support it when ParcelableHolder supports every backend.
	return {name, {}};
	} else {
	return {name, {AidlArgument::Direction::IN_DIR}};
	}
	}

	const AidlDefinedType* t = TryGetDefinedType(name);
	AIDL_FATAL_IF(t == nullptr, type) << "Unrecognized type: '" << name << "'";

	// An 'out' field is passed as an argument, so it doesn't make sense if it is immutable.
	if (t->AsParcelable() != nullptr) {
	if (t->IsJavaOnlyImmutable()) {
	return {"@JavaOnlyImmutable", {AidlArgument::Direction::IN_DIR}};
	}
	return {"parcelable/union",
	{AidlArgument::Direction::IN_DIR, AidlArgument::Direction::OUT_DIR,
	AidlArgument::Direction::INOUT_DIR}};
	}

	return {t->GetPreprocessDeclarationName(), {AidlArgument::Direction::IN_DIR}};
	}

	const AidlEnumDeclaration* AidlTypenames::GetEnumDeclaration(const AidlTypeSpecifier& type) const {
	if (auto defined_type = TryGetDefinedType(type.GetName()); defined_type != nullptr) {
	if (auto enum_decl = defined_type->AsEnumDeclaration(); enum_decl != nullptr) {
	return enum_decl;
	}
	}
	return nullptr;
	}

	const AidlInterface* AidlTypenames::GetInterface(const AidlTypeSpecifier& type) const {
	if (auto defined_type = TryGetDefinedType(type.GetName()); defined_type != nullptr) {
	if (auto intf = defined_type->AsInterface(); intf != nullptr) {
	return intf;
	}
	}
	return nullptr;
	}

	const AidlParcelable* AidlTypenames::GetParcelable(const AidlTypeSpecifier& type) const {
	if (auto defined_type = TryGetDefinedType(type.GetName()); defined_type != nullptr) {
	if (auto parcelable = defined_type->AsParcelable(); parcelable != nullptr) {
	return parcelable;
	}
	}
	return nullptr;
	}

	void AidlTypenames::IterateTypes(const std::function<void(const AidlDefinedType&)>& body) const {
	for (const auto& kv : defined_types_) {
	body(*kv.second);
	}
	for (const auto& kv : preprocessed_types_) {
	body(*kv.second);
	}
	}

	bool AidlTypenames::Autofill() const {
	bool success = true;
	IterateTypes([&](const AidlDefinedType& type) {
	// BackingType is filled in for all known enums, including imported enums,
	// because other types that may use enums, such as Interface or
	// StructuredParcelable, need to know the enum BackingType when
	// generating code.
	if (auto enum_decl = const_cast<AidlDefinedType&>(type).AsEnumDeclaration(); enum_decl) {
	if (!enum_decl->Autofill(*this)) {
	success = false;
	}
	}
	});
	return success;
	}

	} // namespace aidl
	} // namespace android