android-12.0.0_r34/s

/*
 * 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