| /* |
| * 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/file.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 { |
| if (IsBuiltinTypename(import)) return true; |
| |
| 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 |
| if (ignore_import.find(import) != ignore_import.end()) return true; |
| |
| if (TryGetDefinedType(import)) return true; |
| |
| return false; |
| } |
| |
| // Add a parsed document and populate type names in it. |
| // Name conflict is an error unless one of them is from preprocessed. |
| // For legacy, we populate unqualified names from preprocessed unstructured parcelable types |
| // so that they can be referenced via a simple name. |
| bool AidlTypenames::AddDocument(std::unique_ptr<AidlDocument> doc) { |
| bool is_preprocessed = doc->IsPreprocessed(); |
| std::vector<AidlDefinedType*> types_to_add; |
| // Add types in two steps to avoid adding a type while the doc is rejected. |
| // 1. filter types to add |
| // 2. add types |
| |
| std::function<bool(const std::vector<std::unique_ptr<AidlDefinedType>>&)> collect_types_to_add; |
| collect_types_to_add = [&](auto& types) { |
| for (const auto& type : types) { |
| if (IsBuiltinTypename(type->GetName())) { |
| // ParcelFileDescriptor is treated as a built-in type, but it's also in the framework.aidl. |
| // So aidl should ignore built-in types in framework.aidl to prevent duplication. |
| // (b/130899491) |
| if (is_preprocessed) { |
| continue; |
| } |
| // HasValidNameComponents handles name conflicts with built-in types |
| } |
| |
| if (auto prev_definition = defined_types_.find(type->GetCanonicalName()); |
| prev_definition != defined_types_.end()) { |
| // Skip duplicate type in preprocessed document |
| if (is_preprocessed) { |
| continue; |
| } |
| // Overwrite duplicate type which is already added via preprocessed with a new one |
| if (!prev_definition->second->GetDocument().IsPreprocessed()) { |
| AIDL_ERROR(type) << "redefinition: " << type->GetCanonicalName() << " is defined " |
| << prev_definition->second->GetLocation(); |
| return false; |
| } |
| } |
| |
| if (!HasValidNameComponents(*type)) { |
| return false; |
| } |
| |
| types_to_add.push_back(type.get()); |
| |
| // recursively check nested types |
| if (!collect_types_to_add(type->GetNestedTypes())) { |
| return false; |
| } |
| } |
| return true; |
| }; |
| |
| if (!collect_types_to_add(doc->DefinedTypes())) { |
| return false; |
| } |
| |
| for (const auto& type : types_to_add) { |
| // populate global 'type' namespace with fully-qualified names |
| defined_types_.emplace(type->GetCanonicalName(), type); |
| // preprocessed unstructured parcelable types can be referenced without qualification |
| if (is_preprocessed && type->AsUnstructuredParcelable()) { |
| defined_types_.emplace(type->GetName(), type); |
| } |
| } |
| |
| // transfer ownership of document |
| documents_.push_back(std::move(doc)); |
| return true; |
| } |
| |
| const AidlDocument& AidlTypenames::MainDocument() const { |
| AIDL_FATAL_IF(documents_.size() == 0, AIDL_LOCATION_HERE) << "Main document doesn't exist"; |
| return *(documents_[0]); |
| } |
| |
| 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 { |
| auto found_def = defined_types_.find(type_name); |
| if (found_def != defined_types_.end()) { |
| return found_def->second; |
| } |
| return nullptr; |
| } |
| |
| std::vector<const AidlDefinedType*> AidlTypenames::AllDefinedTypes() const { |
| std::vector<const AidlDefinedType*> res; |
| for (const auto& doc : AllDocuments()) { |
| VisitTopDown( |
| [&](const AidlNode& node) { |
| if (auto defined_type = AidlCast<AidlDefinedType>(node); defined_type) { |
| res.push_back(defined_type); |
| } |
| }, |
| *doc); |
| } |
| 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}; |
| } |
| } |
| |
| std::unique_ptr<AidlTypeSpecifier> AidlTypenames::MakeResolvedType(const AidlLocation& location, |
| const string& name, |
| bool is_array) const { |
| std::optional<ArrayType> array; |
| if (is_array) { |
| array = DynamicArray{}; |
| } |
| std::unique_ptr<AidlTypeSpecifier> type( |
| new AidlTypeSpecifier(location, name, std::move(array), nullptr, {})); |
| AIDL_FATAL_IF(!type->Resolve(*this, nullptr), type) << "Can't make unknown type: " << name; |
| type->MarkVisited(); |
| return type; |
| } |
| |
| // 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(); |
| } |
| |
| // Followings can be FixedSize: |
| // - @FixedSize parcelables |
| // - primitive types and enum types |
| // - fixed-size arrays of FixedSize types |
| bool AidlTypenames::CanBeFixedSize(const AidlTypeSpecifier& type) const { |
| const string& name = type.GetName(); |
| if (type.IsGeneric() || type.IsNullable()) { |
| return false; |
| } |
| if (type.IsArray() && !type.IsFixedSizeArray()) { |
| 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); |
| } |
| } |
| |
| 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 |