Remove TypeNamespace
1. Remove TypeNamesapce
2. In aidl.cpp, just validate language specific restriction(validate_type)
instead of register_type
Test: m
Test: ./runtests.sh
Bug: 110967839
Change-Id: I7406f5b326af4e2342059aef9277ddfb24775ce9
diff --git a/Android.bp b/Android.bp
index 44581fd..44ef1b2 100644
--- a/Android.bp
+++ b/Android.bp
@@ -62,9 +62,6 @@
"line_reader.cpp",
"io_delegate.cpp",
"options.cpp",
- "type_cpp.cpp",
- "type_java.cpp",
- "type_namespace.cpp",
],
yacc: {
gen_location_hh: true,
@@ -124,8 +121,6 @@
"tests/test_data_ping_responder.cpp",
"tests/test_data_string_constants.cpp",
"tests/test_util.cpp",
- "type_cpp_unittest.cpp",
- "type_java_unittest.cpp",
],
static_libs: [
diff --git a/aidl.cpp b/aidl.cpp
index 28f791e..3483593 100644
--- a/aidl.cpp
+++ b/aidl.cpp
@@ -46,9 +46,6 @@
#include "logging.h"
#include "options.h"
#include "os.h"
-#include "type_cpp.h"
-#include "type_java.h"
-#include "type_namespace.h"
#ifndef O_BINARY
# define O_BINARY 0
@@ -152,62 +149,6 @@
return valid;
}
-bool register_types(const AidlStructuredParcelable* parcel, TypeNamespace* types) {
- for (const auto& v : parcel->GetFields()) {
- if (!types->MaybeAddContainerType(v->GetType())) {
- return false;
- }
-
- const ValidatableType* type = types->GetReturnType(v->GetType(), *parcel);
- if (type == nullptr) {
- return false;
- }
- v->GetMutableType()->SetLanguageType(type);
- }
- return true;
-}
-
-bool register_types(const AidlInterface* c, TypeNamespace* types) {
- for (const auto& m : c->GetMethods()) {
- if (!types->MaybeAddContainerType(m->GetType())) {
- return false;
- }
-
- const ValidatableType* return_type = types->GetReturnType(m->GetType(), *c);
-
- if (return_type == nullptr) {
- return false;
- }
- m->GetMutableType()->SetLanguageType(return_type);
-
- set<string> argument_names;
-
- int index = 1;
- for (const auto& arg : m->GetArguments()) {
- if (!types->MaybeAddContainerType(arg->GetType())) {
- return false;
- }
-
- const ValidatableType* arg_type = types->GetArgType(*arg, index, *c);
- if (arg_type == nullptr) {
- return false;
- }
- arg->GetMutableType()->SetLanguageType(arg_type);
- }
- }
-
- for (const std::unique_ptr<AidlConstantDeclaration>& constant : c->GetConstantDeclarations()) {
- AidlTypeSpecifier* specifier = constant->GetMutableType();
- const ValidatableType* return_type = types->GetReturnType(*specifier, *c);
- if (return_type == nullptr) {
- return false;
- }
- specifier->SetLanguageType(return_type);
- }
-
- return true;
-}
-
bool write_dep_file(const Options& options, const AidlDefinedType& defined_type,
const vector<string>& imports, const IoDelegate& io_delegate,
const string& input_file, const string& output_file) {
@@ -399,7 +340,7 @@
namespace internals {
bool parse_preprocessed_file(const IoDelegate& io_delegate, const string& filename,
- TypeNamespace* types, AidlTypenames& typenames) {
+ AidlTypenames* typenames) {
bool success = true;
unique_ptr<LineReader> line_reader = io_delegate.GetLineReader(filename);
if (!line_reader) {
@@ -436,20 +377,17 @@
}
AidlParcelable* doc = new AidlParcelable(
location, new AidlQualifiedName(location, class_name, ""), package, "" /* comments */);
- types->AddParcelableType(*doc, filename);
- typenames.AddPreprocessedType(unique_ptr<AidlParcelable>(doc));
+ typenames->AddPreprocessedType(unique_ptr<AidlParcelable>(doc));
} else if (decl == "structured_parcelable") {
auto temp = new std::vector<std::unique_ptr<AidlVariableDeclaration>>();
AidlStructuredParcelable* doc =
new AidlStructuredParcelable(location, new AidlQualifiedName(location, class_name, ""),
package, "" /* comments */, temp);
- types->AddParcelableType(*doc, filename);
- typenames.AddPreprocessedType(unique_ptr<AidlStructuredParcelable>(doc));
+ typenames->AddPreprocessedType(unique_ptr<AidlStructuredParcelable>(doc));
} else if (decl == "interface") {
auto temp = new std::vector<std::unique_ptr<AidlMember>>();
AidlInterface* doc = new AidlInterface(location, class_name, "", false, temp, package);
- types->AddBinderType(*doc, filename);
- typenames.AddPreprocessedType(unique_ptr<AidlInterface>(doc));
+ typenames->AddPreprocessedType(unique_ptr<AidlInterface>(doc));
} else {
success = false;
break;
@@ -464,7 +402,7 @@
}
AidlError load_and_validate_aidl(const std::string& input_file_name, const Options& options,
- const IoDelegate& io_delegate, TypeNamespace* types,
+ const IoDelegate& io_delegate, AidlTypenames* typenames,
vector<AidlDefinedType*>* defined_types,
vector<string>* imported_files) {
AidlError err = AidlError::OK;
@@ -474,8 +412,7 @@
//////////////////////////////////////////////////////////////////////////
// Parse the main input file
- std::unique_ptr<Parser> main_parser =
- Parser::Parse(input_file_name, io_delegate, types->typenames_);
+ std::unique_ptr<Parser> main_parser = Parser::Parse(input_file_name, io_delegate, *typenames);
if (main_parser == nullptr) {
return AidlError::PARSE_ERROR;
}
@@ -483,13 +420,10 @@
AIDL_ERROR(input_file_name) << "You must declare only one type per a file.";
return AidlError::BAD_TYPE;
}
- if (!types->AddDefinedTypes(main_parser->GetDefinedTypes(), input_file_name)) {
- return AidlError::BAD_TYPE;
- }
// Import the preprocessed file
for (const string& s : options.PreprocessedFiles()) {
- if (!parse_preprocessed_file(io_delegate, s, types, types->typenames_)) {
+ if (!parse_preprocessed_file(io_delegate, s, typenames)) {
err = AidlError::BAD_PRE_PROCESSED_FILE;
}
}
@@ -523,7 +457,7 @@
set<string> import_candidates(type_from_import_statements);
import_candidates.insert(unresolved_types.begin(), unresolved_types.end());
for (const auto& import : import_candidates) {
- if (types->HasImportType(import)) {
+ if (typenames->IsIgnorableImport(import)) {
// There are places in the Android tree where an import doesn't resolve,
// but we'll pick the type up through the preprocessed types.
// This seems like an error, but legacy support demands we support it...
@@ -541,16 +475,12 @@
import_paths.emplace_back(import_path);
- std::unique_ptr<Parser> import_parser =
- Parser::Parse(import_path, io_delegate, types->typenames_);
+ std::unique_ptr<Parser> import_parser = Parser::Parse(import_path, io_delegate, *typenames);
if (import_parser == nullptr) {
cerr << "error while importing " << import_path << " for " << import << endl;
err = AidlError::BAD_IMPORT;
continue;
}
- if (!types->AddDefinedTypes(import_parser->GetDefinedTypes(), import_path)) {
- return AidlError::BAD_TYPE;
- }
}
if (err != AidlError::OK) {
return err;
@@ -559,16 +489,12 @@
for (const auto& imported_file : options.ImportFiles()) {
import_paths.emplace_back(imported_file);
- std::unique_ptr<Parser> import_parser =
- Parser::Parse(imported_file, io_delegate, types->typenames_);
+ std::unique_ptr<Parser> import_parser = Parser::Parse(imported_file, io_delegate, *typenames);
if (import_parser == nullptr) {
AIDL_ERROR(imported_file) << "error while importing " << imported_file;
err = AidlError::BAD_IMPORT;
continue;
}
- if (!types->AddDefinedTypes(import_parser->GetDefinedTypes(), imported_file)) {
- return AidlError::BAD_TYPE;
- }
}
if (err != AidlError::OK) {
return err;
@@ -581,34 +507,10 @@
// using fully qualified names.
return AidlError::BAD_TYPE;
}
- if (!is_check_api) {
- for (const auto defined_type : main_parser->GetDefinedTypes()) {
- AidlInterface* interface = defined_type->AsInterface();
- AidlStructuredParcelable* parcelable = defined_type->AsStructuredParcelable();
-
- // Link the AIDL type with the type of the target language. This will
- // be removed when the migration to AidlTypenames is done.
- defined_type->SetLanguageType(types->GetDefinedType(*defined_type));
-
- if (interface != nullptr) {
- if (!register_types(interface, types)) {
- return AidlError::BAD_TYPE;
- }
- }
- if (parcelable != nullptr) {
- if (!register_types(parcelable, types)) {
- return AidlError::BAD_TYPE;
- }
- }
- }
- }
-
//////////////////////////////////////////////////////////////////////////
// Validation phase
//////////////////////////////////////////////////////////////////////////
- AidlTypenames& typenames = types->typenames_;
-
// For legacy reasons, by default, compiling an unstructured parcelable (which contains no output)
// is allowed. This must not be returned as an error until the very end of this procedure since
// this may be considered a success, and we should first check that there are not other, more
@@ -618,9 +520,20 @@
const int num_defined_types = main_parser->GetDefinedTypes().size();
for (const auto defined_type : main_parser->GetDefinedTypes()) {
CHECK(defined_type != nullptr);
+
+ // Language specific validation
+ AidlError check_result = AidlError::OK;
+ if (!defined_type->LanguageSpecificCheckValid(options.TargetLanguage())) {
+ return AidlError::BAD_TYPE;
+ }
+
+ if (check_result != AidlError::OK) {
+ return check_result;
+ }
+
AidlParcelable* unstructuredParcelable = defined_type->AsUnstructuredParcelable();
if (unstructuredParcelable != nullptr) {
- if (!unstructuredParcelable->CheckValid(typenames)) {
+ if (!unstructuredParcelable->CheckValid(*typenames)) {
return AidlError::BAD_TYPE;
}
bool isStable = unstructuredParcelable->IsStableParcelable();
@@ -662,7 +575,7 @@
if (!is_check_api) {
// No need to do this for check api because all typespecs are already
// using fully qualified name and we don't import in AIDL files.
- if (!defined_type->CheckValid(typenames)) {
+ if (!defined_type->CheckValid(*typenames)) {
return AidlError::BAD_TYPE;
}
}
@@ -672,7 +585,7 @@
if (options.Version() > 0) {
AidlTypeSpecifier* ret =
new AidlTypeSpecifier(AIDL_LOCATION_HERE, "int", false, nullptr, "");
- ret->Resolve(typenames);
+ ret->Resolve(*typenames);
vector<unique_ptr<AidlArgument>>* args = new vector<unique_ptr<AidlArgument>>();
AidlMethod* method =
new AidlMethod(AIDL_LOCATION_HERE, false, ret, "getInterfaceVersion", args, "",
@@ -685,7 +598,7 @@
}
}
- typenames.IterateTypes([&](const AidlDefinedType& type) {
+ typenames->IterateTypes([&](const AidlDefinedType& type) {
if (options.IsStructured() && type.AsUnstructuredParcelable() != nullptr &&
!type.AsUnstructuredParcelable()->IsStableParcelable()) {
err = AidlError::NOT_STRUCTURED;
@@ -724,30 +637,13 @@
int compile_aidl(const Options& options, const IoDelegate& io_delegate) {
const Options::Language lang = options.TargetLanguage();
for (const string& input_file : options.InputFiles()) {
- // Create type namespace that will hold the types identified by the parser.
- // This two namespaces that are specific to the target language will be
- // unified to AidlTypenames which is agnostic to the target language.
- cpp::TypeNamespace cpp_types;
- cpp_types.Init();
-
- java::JavaTypeNamespace java_types;
- java_types.Init();
-
- TypeNamespace* types;
- if (options.IsCppOutput()) {
- types = &cpp_types;
- } else if (lang == Options::Language::JAVA) {
- types = &java_types;
- } else {
- LOG(FATAL) << "Unsupported target language." << endl;
- return 1;
- }
+ AidlTypenames typenames;
vector<AidlDefinedType*> defined_types;
vector<string> imported_files;
- AidlError aidl_err = internals::load_and_validate_aidl(input_file, options, io_delegate, types,
- &defined_types, &imported_files);
+ AidlError aidl_err = internals::load_and_validate_aidl(
+ input_file, options, io_delegate, &typenames, &defined_types, &imported_files);
bool allowError = aidl_err == AidlError::FOUND_PARCELABLE && !options.FailOnParcelable();
if (aidl_err != AidlError::OK && !allowError) {
return 1;
@@ -772,15 +668,14 @@
bool success = false;
if (lang == Options::Language::CPP) {
- success = cpp::GenerateCpp(output_file_name, options, cpp_types.typenames_, *defined_type,
- io_delegate);
+ success =
+ cpp::GenerateCpp(output_file_name, options, typenames, *defined_type, io_delegate);
} else if (lang == Options::Language::NDK) {
- ndk::GenerateNdk(output_file_name, options, cpp_types.typenames_, *defined_type,
- io_delegate);
+ ndk::GenerateNdk(output_file_name, options, typenames, *defined_type, io_delegate);
success = true;
} else if (lang == Options::Language::JAVA) {
- success = java::generate_java(output_file_name, defined_type, java_types.typenames_,
- io_delegate, options);
+ success =
+ java::generate_java(output_file_name, defined_type, typenames, io_delegate, options);
} else {
LOG(FATAL) << "Should not reach here" << endl;
return 1;
@@ -796,13 +691,12 @@
bool dump_mappings(const Options& options, const IoDelegate& io_delegate) {
android::aidl::mappings::SignatureMap all_mappings;
for (const string& input_file : options.InputFiles()) {
- java::JavaTypeNamespace java_types;
- java_types.Init();
+ AidlTypenames typenames;
vector<AidlDefinedType*> defined_types;
vector<string> imported_files;
AidlError aidl_err = internals::load_and_validate_aidl(
- input_file, options, io_delegate, &java_types, &defined_types, &imported_files);
+ input_file, options, io_delegate, &typenames, &defined_types, &imported_files);
if (aidl_err != AidlError::OK) {
LOG(WARNING) << "AIDL file is invalid.\n";
continue;
@@ -849,10 +743,9 @@
bool dump_api(const Options& options, const IoDelegate& io_delegate) {
for (const auto& file : options.InputFiles()) {
- java::JavaTypeNamespace ns;
- ns.Init();
+ AidlTypenames typenames;
vector<AidlDefinedType*> defined_types;
- if (internals::load_and_validate_aidl(file, options, io_delegate, &ns, &defined_types,
+ if (internals::load_and_validate_aidl(file, options, io_delegate, &typenames, &defined_types,
nullptr) == AidlError::OK) {
for (const auto type : defined_types) {
unique_ptr<CodeWriter> writer =
diff --git a/aidl.h b/aidl.h
index 5b5799c..955b280 100644
--- a/aidl.h
+++ b/aidl.h
@@ -25,7 +25,6 @@
#include "import_resolver.h"
#include "io_delegate.h"
#include "options.h"
-#include "type_namespace.h"
namespace android {
namespace aidl {
@@ -56,12 +55,12 @@
namespace internals {
AidlError load_and_validate_aidl(const std::string& input_file_name, const Options& options,
- const IoDelegate& io_delegate, TypeNamespace* types,
+ const IoDelegate& io_delegate, AidlTypenames* typenames,
vector<AidlDefinedType*>* defined_types,
vector<string>* imported_files);
bool parse_preprocessed_file(const IoDelegate& io_delegate, const std::string& filename,
- TypeNamespace* types, AidlTypenames& typenames);
+ AidlTypenames* typenames);
} // namespace internals
diff --git a/aidl_apicheck.cpp b/aidl_apicheck.cpp
index 4bedd17..3030ebd 100644
--- a/aidl_apicheck.cpp
+++ b/aidl_apicheck.cpp
@@ -16,8 +16,8 @@
#include "aidl.h"
#include "aidl_language.h"
#include "import_resolver.h"
+#include "logging.h"
#include "options.h"
-#include "type_java.h"
#include <map>
#include <string>
@@ -179,9 +179,7 @@
CHECK(options.IsStructured());
CHECK(options.InputFiles().size() == 2) << "--checkapi requires two inputs "
<< "but got " << options.InputFiles().size();
-
- java::JavaTypeNamespace old_ns;
- old_ns.Init();
+ AidlTypenames old_tns;
const string old_dir = options.InputFiles().at(0);
vector<AidlDefinedType*> old_types;
vector<string> old_files = io_delegate.ListFiles(old_dir);
@@ -191,7 +189,7 @@
}
for (const auto& file : old_files) {
vector<AidlDefinedType*> types;
- if (internals::load_and_validate_aidl(file, options, io_delegate, &old_ns, &types,
+ if (internals::load_and_validate_aidl(file, options, io_delegate, &old_tns, &types,
nullptr /* imported_files */) != AidlError::OK) {
AIDL_ERROR(file) << "Failed to read.";
return false;
@@ -199,8 +197,7 @@
old_types.insert(old_types.end(), types.begin(), types.end());
}
- java::JavaTypeNamespace new_ns;
- new_ns.Init();
+ AidlTypenames new_tns;
const string new_dir = options.InputFiles().at(1);
vector<AidlDefinedType*> new_types;
vector<string> new_files = io_delegate.ListFiles(new_dir);
@@ -210,7 +207,7 @@
}
for (const auto& file : new_files) {
vector<AidlDefinedType*> types;
- if (internals::load_and_validate_aidl(file, options, io_delegate, &new_ns, &types,
+ if (internals::load_and_validate_aidl(file, options, io_delegate, &new_tns, &types,
nullptr /* imported_files */) != AidlError::OK) {
AIDL_ERROR(file) << "Failed to read.";
return false;
diff --git a/aidl_language.cpp b/aidl_language.cpp
index 6068415..5eeb8ad 100644
--- a/aidl_language.cpp
+++ b/aidl_language.cpp
@@ -17,7 +17,6 @@
#include "aidl_language_y.h"
#include "logging.h"
-#include "type_namespace.h"
#ifdef _WIN32
int isatty(int fd)
@@ -37,6 +36,22 @@
using std::unique_ptr;
using std::vector;
+namespace {
+bool is_java_keyword(const char* str) {
+ static const std::vector<std::string> kJavaKeywords{
+ "abstract", "assert", "boolean", "break", "byte", "case", "catch",
+ "char", "class", "const", "continue", "default", "do", "double",
+ "else", "enum", "extends", "final", "finally", "float", "for",
+ "goto", "if", "implements", "import", "instanceof", "int", "interface",
+ "long", "native", "new", "package", "private", "protected", "public",
+ "return", "short", "static", "strictfp", "super", "switch", "synchronized",
+ "this", "throw", "throws", "transient", "try", "void", "volatile",
+ "while", "true", "false", "null",
+ };
+ return std::find(kJavaKeywords.begin(), kJavaKeywords.end(), str) != kJavaKeywords.end();
+}
+} // namespace
+
void yylex_init(void **);
void yylex_destroy(void *);
void yyset_in(FILE *f, void *);
@@ -780,6 +795,88 @@
return true;
}
+// TODO: we should treat every backend all the same in future.
+bool AidlTypeSpecifier::LanguageSpecificCheckValid(Options::Language lang) const {
+ if (lang == Options::Language::CPP) {
+ if (this->GetName() == "List" && !this->IsGeneric()) {
+ AIDL_ERROR(this) << "List without type isn't supported in cpp.";
+ return false;
+ }
+ }
+ if (this->IsGeneric()) {
+ if (this->GetName() == "List") {
+ if (this->GetTypeParameters().size() != 1) {
+ AIDL_ERROR(this) << "List must have only one type parameter.";
+ return false;
+ }
+ if (lang == Options::Language::CPP) {
+ auto& name = this->GetTypeParameters()[0]->GetName();
+ if (!(name == "String" || name == "IBinder")) {
+ AIDL_ERROR(this) << "List in cpp supports only string and IBinder for now.";
+ return false;
+ }
+ } else if (lang == Options::Language::NDK) {
+ AIDL_ERROR(this) << "NDK backend does not support List yet.";
+ return false;
+ }
+
+ } else if (this->GetName() == "Map") {
+ if (lang != Options::Language::JAVA) {
+ AIDL_ERROR(this) << "Currently, only Java backend supports Map.";
+ return false;
+ }
+ }
+ }
+ return true;
+}
+
+// TODO: we should treat every backend all the same in future.
+bool AidlParcelable::LanguageSpecificCheckValid(Options::Language lang) const {
+ if (lang != Options::Language::JAVA) {
+ if (this->IsStableParcelable()) {
+ AIDL_ERROR(this) << "@JavaOnlyStableParcelable supports only Java target.";
+ return false;
+ }
+ const AidlParcelable* unstructuredParcelable = this->AsUnstructuredParcelable();
+ if (unstructuredParcelable != nullptr) {
+ if (unstructuredParcelable->GetCppHeader().empty()) {
+ AIDL_ERROR(unstructuredParcelable)
+ << "Unstructured parcelable must have C++ header defined.";
+ return false;
+ }
+ }
+ }
+ return true;
+}
+
+// TODO: we should treat every backend all the same in future.
+bool AidlStructuredParcelable::LanguageSpecificCheckValid(Options::Language lang) const {
+ if (!AidlParcelable::LanguageSpecificCheckValid(lang)) {
+ return false;
+ }
+ for (const auto& v : this->GetFields()) {
+ if (!v->GetType().LanguageSpecificCheckValid(lang)) {
+ return false;
+ }
+ }
+ return true;
+}
+
+// TODO: we should treat every backend all the same in future.
+bool AidlInterface::LanguageSpecificCheckValid(Options::Language lang) const {
+ for (const auto& m : this->GetMethods()) {
+ if (!m->GetType().LanguageSpecificCheckValid(lang)) {
+ return false;
+ }
+ for (const auto& arg : m->GetArguments()) {
+ if (!arg->GetType().LanguageSpecificCheckValid(lang)) {
+ return false;
+ }
+ }
+ }
+ return true;
+}
+
AidlInterface::AidlInterface(const AidlLocation& location, const std::string& name,
const std::string& comments, bool oneway,
std::vector<std::unique_ptr<AidlMember>>* members,
@@ -852,6 +949,29 @@
AIDL_ERROR(m) << "oneway method '" << m->GetName() << "' cannot have out parameters";
return false;
}
+ const bool can_be_out = typenames.CanBeOutParameter(arg->GetType());
+ if (!arg->DirectionWasSpecified() && can_be_out) {
+ AIDL_ERROR(arg) << "'" << arg->GetType().ToString()
+ << "' can be an out type, so you must declare it as in, out, or inout.";
+ return false;
+ }
+
+ if (arg->GetDirection() != AidlArgument::IN_DIR && !can_be_out) {
+ AIDL_ERROR(arg) << "'" << arg->ToString() << "' can only be an in parameter.";
+ return false;
+ }
+
+ // check that the name doesn't match a keyword
+ if (is_java_keyword(arg->GetName().c_str())) {
+ AIDL_ERROR(arg) << "Argument name is a Java or aidl keyword";
+ return false;
+ }
+
+ // Reserve a namespace for internal use
+ if (android::base::StartsWith(arg->GetName(), "_aidl")) {
+ AIDL_ERROR(arg) << "Argument name cannot begin with '_aidl'";
+ return false;
+ }
}
auto it = method_names.find(m->GetName());
diff --git a/aidl_language.h b/aidl_language.h
index 3895432..ee8a201 100644
--- a/aidl_language.h
+++ b/aidl_language.h
@@ -3,6 +3,7 @@
#include "aidl_typenames.h"
#include "code_writer.h"
#include "io_delegate.h"
+#include "options.h"
#include <memory>
#include <string>
@@ -16,11 +17,11 @@
using android::aidl::AidlTypenames;
using android::aidl::CodeWriter;
+using android::aidl::Options;
using std::shared_ptr;
using std::string;
using std::unique_ptr;
using std::vector;
-
class AidlNode;
namespace android {
@@ -257,6 +258,7 @@
bool Resolve(android::aidl::AidlTypenames& typenames);
bool CheckValid(const AidlTypenames& typenames) const;
+ bool LanguageSpecificCheckValid(Options::Language lang) const;
void SetLanguageType(const android::aidl::ValidatableType* language_type) {
language_type_ = language_type;
@@ -536,7 +538,7 @@
virtual const AidlParcelable* AsParcelable() const { return nullptr; }
virtual const AidlInterface* AsInterface() const { return nullptr; }
virtual bool CheckValid(const AidlTypenames&) const { return CheckValidAnnotations(); }
-
+ virtual bool LanguageSpecificCheckValid(Options::Language lang) const = 0;
AidlStructuredParcelable* AsStructuredParcelable() {
return const_cast<AidlStructuredParcelable*>(
const_cast<const AidlDefinedType*>(this)->AsStructuredParcelable());
@@ -589,7 +591,7 @@
std::string GetCppHeader() const { return cpp_header_; }
bool CheckValid(const AidlTypenames& typenames) const override;
-
+ bool LanguageSpecificCheckValid(Options::Language lang) const override;
const AidlParcelable* AsParcelable() const override { return this; }
std::string GetPreprocessDeclarationName() const override { return "parcelable"; }
@@ -618,6 +620,7 @@
void Write(CodeWriter* writer) const override;
bool CheckValid(const AidlTypenames& typenames) const override;
+ bool LanguageSpecificCheckValid(Options::Language lang) const override;
private:
const std::vector<std::unique_ptr<AidlVariableDeclaration>> variables_;
@@ -645,6 +648,7 @@
void Write(CodeWriter* writer) const override;
bool CheckValid(const AidlTypenames& typenames) const override;
+ bool LanguageSpecificCheckValid(Options::Language lang) const override;
private:
std::vector<std::unique_ptr<AidlMethod>> methods_;
diff --git a/aidl_typenames.cpp b/aidl_typenames.cpp
index 3b79aba..32b03bd 100644
--- a/aidl_typenames.cpp
+++ b/aidl_typenames.cpp
@@ -81,6 +81,13 @@
return true;
}
+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"};
+ return ResolveTypename(import).second || ignore_import.find(import) != ignore_import.end();
+}
+
bool AidlTypenames::AddDefinedType(unique_ptr<AidlDefinedType> type) {
const string name = type->GetCanonicalName();
if (defined_types_.find(name) != defined_types_.end()) {
diff --git a/aidl_typenames.h b/aidl_typenames.h
index 74db49c..3a64ef2 100644
--- a/aidl_typenames.h
+++ b/aidl_typenames.h
@@ -58,7 +58,7 @@
const AidlDefinedType* TryGetDefinedType(const string& type_name) const;
pair<string, bool> ResolveTypename(const string& type_name) const;
bool CanBeOutParameter(const AidlTypeSpecifier& type) const;
-
+ bool IsIgnorableImport(const string& import) const;
// Iterates over all defined and then preprocessed types
void IterateTypes(const std::function<void(const AidlDefinedType&)>& body) const;
diff --git a/aidl_unittest.cpp b/aidl_unittest.cpp
index 2a5a5d7..3763f75 100644
--- a/aidl_unittest.cpp
+++ b/aidl_unittest.cpp
@@ -26,10 +26,9 @@
#include "aidl_apicheck.h"
#include "aidl_language.h"
#include "aidl_to_cpp.h"
+#include "aidl_to_java.h"
+#include "options.h"
#include "tests/fake_io_delegate.h"
-#include "type_cpp.h"
-#include "type_java.h"
-#include "type_namespace.h"
using android::aidl::internals::parse_preprocessed_file;
using android::aidl::test::FakeIoDelegate;
@@ -144,8 +143,6 @@
class AidlTest : public ::testing::Test {
protected:
void SetUp() override {
- java_types_.Init();
- cpp_types_.Init();
CaptureStderr();
}
@@ -158,15 +155,15 @@
void AddExpectedStderr(string expected) { expected_stderr_.push_back(expected); }
- AidlDefinedType* Parse(const string& path, const string& contents, TypeNamespace* types,
- AidlError* error = nullptr,
+ AidlDefinedType* Parse(const string& path, const string& contents, AidlTypenames& typenames_,
+ Options::Language lang, AidlError* error = nullptr,
const vector<string> additional_arguments = {}) {
io_delegate_.SetFileContents(path, contents);
vector<string> args;
- if (types == &java_types_) {
- args.emplace_back("aidl");
- } else {
+ if (lang == Options::Language::CPP) {
args.emplace_back("aidl-cpp");
+ } else {
+ args.emplace_back("aidl");
}
for (const string& s : additional_arguments) {
args.emplace_back(s);
@@ -183,7 +180,7 @@
vector<string> imported_files;
ImportResolver import_resolver{io_delegate_, path, import_paths_, {}};
AidlError actual_error = ::android::aidl::internals::load_and_validate_aidl(
- path, options, io_delegate_, types, &defined_types, &imported_files);
+ path, options, io_delegate_, &typenames_, &defined_types, &imported_files);
if (error != nullptr) {
*error = actual_error;
@@ -202,18 +199,21 @@
vector<string> preprocessed_files_;
set<string> import_paths_;
vector<string> expected_stderr_;
- java::JavaTypeNamespace java_types_;
- cpp::TypeNamespace cpp_types_;
+ AidlTypenames typenames_;
};
TEST_F(AidlTest, AcceptMissingPackage) {
- EXPECT_NE(nullptr, Parse("IFoo.aidl", "interface IFoo { }", &java_types_));
- EXPECT_NE(nullptr, Parse("IFoo.aidl", "interface IFoo { }", &cpp_types_));
+ EXPECT_NE(nullptr, Parse("IFoo.aidl", "interface IFoo { }", typenames_, Options::Language::JAVA));
+ typenames_.Reset();
+ EXPECT_NE(nullptr, Parse("IFoo.aidl", "interface IFoo { }", typenames_, Options::Language::CPP));
}
TEST_F(AidlTest, EndsInSingleLineComment) {
- EXPECT_NE(nullptr, Parse("IFoo.aidl", "interface IFoo { } // foo", &java_types_));
- EXPECT_NE(nullptr, Parse("IFoo.aidl", "interface IFoo { } // foo", &cpp_types_));
+ EXPECT_NE(nullptr,
+ Parse("IFoo.aidl", "interface IFoo { } // foo", typenames_, Options::Language::JAVA));
+ typenames_.Reset();
+ EXPECT_NE(nullptr,
+ Parse("IFoo.aidl", "interface IFoo { } // foo", typenames_, Options::Language::CPP));
}
TEST_F(AidlTest, RejectsArraysOfBinders) {
@@ -224,18 +224,22 @@
string contents = "package foo;\n"
"import bar.IBar;\n"
"interface IFoo { void f(in IBar[] input); }";
- EXPECT_EQ(nullptr, Parse(path, contents, &java_types_));
- EXPECT_EQ(nullptr, Parse(path, contents, &cpp_types_));
+ EXPECT_EQ(nullptr, Parse(path, contents, typenames_, Options::Language::JAVA));
+ typenames_.Reset();
+ EXPECT_EQ(nullptr, Parse(path, contents, typenames_, Options::Language::CPP));
}
TEST_F(AidlTest, SupportOnlyOutParameters) {
string interface_list = "package a; interface IBar { void f(out List bar); }";
string interface_ibinder = "package a; interface IBaz { void f(out IBinder bar); }";
// List without type isn't supported in cpp.
- EXPECT_EQ(nullptr, Parse("a/IBar.aidl", interface_list, &cpp_types_));
- EXPECT_NE(nullptr, Parse("a/IBar.aidl", interface_list, &java_types_));
- EXPECT_EQ(nullptr, Parse("a/IBaz.aidl", interface_ibinder, &cpp_types_));
- EXPECT_EQ(nullptr, Parse("a/IBaz.aidl", interface_ibinder, &java_types_));
+ EXPECT_EQ(nullptr, Parse("a/IBar.aidl", interface_list, typenames_, Options::Language::CPP));
+ typenames_.Reset();
+ EXPECT_NE(nullptr, Parse("a/IBar.aidl", interface_list, typenames_, Options::Language::JAVA));
+ typenames_.Reset();
+ EXPECT_EQ(nullptr, Parse("a/IBaz.aidl", interface_ibinder, typenames_, Options::Language::CPP));
+ typenames_.Reset();
+ EXPECT_EQ(nullptr, Parse("a/IBaz.aidl", interface_ibinder, typenames_, Options::Language::JAVA));
}
TEST_F(AidlTest, RejectsOnewayOutParameters) {
@@ -243,49 +247,55 @@
"package a; oneway interface IFoo { void f(out int bar); }";
string oneway_method =
"package a; interface IBar { oneway void f(out int bar); }";
- EXPECT_EQ(nullptr, Parse("a/IFoo.aidl", oneway_interface, &cpp_types_));
- EXPECT_EQ(nullptr, Parse("a/IFoo.aidl", oneway_interface, &java_types_));
- EXPECT_EQ(nullptr, Parse("a/IBar.aidl", oneway_method, &cpp_types_));
- EXPECT_EQ(nullptr, Parse("a/IBar.aidl", oneway_method, &java_types_));
+ EXPECT_EQ(nullptr, Parse("a/IFoo.aidl", oneway_interface, typenames_, Options::Language::CPP));
+ typenames_.Reset();
+ EXPECT_EQ(nullptr, Parse("a/IFoo.aidl", oneway_interface, typenames_, Options::Language::JAVA));
+ typenames_.Reset();
+ EXPECT_EQ(nullptr, Parse("a/IBar.aidl", oneway_method, typenames_, Options::Language::CPP));
+ typenames_.Reset();
+ EXPECT_EQ(nullptr, Parse("a/IBar.aidl", oneway_method, typenames_, Options::Language::JAVA));
}
TEST_F(AidlTest, RejectsOnewayNonVoidReturn) {
string oneway_method = "package a; interface IFoo { oneway int f(); }";
- EXPECT_EQ(nullptr, Parse("a/IFoo.aidl", oneway_method, &cpp_types_));
- EXPECT_EQ(nullptr, Parse("a/IFoo.aidl", oneway_method, &java_types_));
+ EXPECT_EQ(nullptr, Parse("a/IFoo.aidl", oneway_method, typenames_, Options::Language::CPP));
+ typenames_.Reset();
+ EXPECT_EQ(nullptr, Parse("a/IFoo.aidl", oneway_method, typenames_, Options::Language::JAVA));
}
TEST_F(AidlTest, RejectsNullablePrimitive) {
string oneway_method = "package a; interface IFoo { @nullable int f(); }";
- EXPECT_EQ(nullptr, Parse("a/IFoo.aidl", oneway_method, &cpp_types_));
- EXPECT_EQ(nullptr, Parse("a/IFoo.aidl", oneway_method, &java_types_));
+ EXPECT_EQ(nullptr, Parse("a/IFoo.aidl", oneway_method, typenames_, Options::Language::CPP));
+ typenames_.Reset();
+ EXPECT_EQ(nullptr, Parse("a/IFoo.aidl", oneway_method, typenames_, Options::Language::JAVA));
}
TEST_F(AidlTest, RejectsDuplicatedArgumentNames) {
string method = "package a; interface IFoo { void f(int a, int a); }";
- EXPECT_EQ(nullptr, Parse("a/IFoo.aidl", method, &cpp_types_));
- EXPECT_EQ(nullptr, Parse("a/IFoo.aidl", method, &java_types_));
+ EXPECT_EQ(nullptr, Parse("a/IFoo.aidl", method, typenames_, Options::Language::CPP));
+ typenames_.Reset();
+ EXPECT_EQ(nullptr, Parse("a/IFoo.aidl", method, typenames_, Options::Language::JAVA));
}
TEST_F(AidlTest, RejectsDuplicatedAnnotationParams) {
string method = "package a; interface IFoo { @UnsupportedAppUsage(foo=1, foo=2)void f(); }";
- EXPECT_EQ(nullptr, Parse("a/IFoo.aidl", method, &cpp_types_));
- EXPECT_EQ(nullptr, Parse("a/IFoo.aidl", method, &java_types_));
+ EXPECT_EQ(nullptr, Parse("a/IFoo.aidl", method, typenames_, Options::Language::CPP));
+ typenames_.Reset();
+ EXPECT_EQ(nullptr, Parse("a/IFoo.aidl", method, typenames_, Options::Language::JAVA));
}
TEST_F(AidlTest, ParsesNullableAnnotation) {
for (auto is_nullable: {true, false}) {
- auto parse_result = Parse(
- "a/IFoo.aidl",
- StringPrintf( "package a; interface IFoo {%s String f(); }",
- (is_nullable) ? "@nullable" : ""),
- &cpp_types_);
+ auto parse_result = Parse("a/IFoo.aidl",
+ StringPrintf("package a; interface IFoo {%s String f(); }",
+ (is_nullable) ? "@nullable" : ""),
+ typenames_, Options::Language::CPP);
ASSERT_NE(nullptr, parse_result);
const AidlInterface* interface = parse_result->AsInterface();
ASSERT_NE(nullptr, interface);
ASSERT_FALSE(interface->GetMethods().empty());
EXPECT_EQ(interface->GetMethods()[0]->GetType().IsNullable(), is_nullable);
- cpp_types_.typenames_.Reset();
+ typenames_.Reset();
}
}
@@ -293,51 +303,52 @@
for (auto is_utf8: {true, false}) {
auto parse_result = Parse(
"a/IFoo.aidl",
- StringPrintf( "package a; interface IFoo {%s String f(); }",
- (is_utf8) ? "@utf8InCpp" : ""),
- &cpp_types_);
+ StringPrintf("package a; interface IFoo {%s String f(); }", (is_utf8) ? "@utf8InCpp" : ""),
+ typenames_, Options::Language::CPP);
ASSERT_NE(nullptr, parse_result);
const AidlInterface* interface = parse_result->AsInterface();
ASSERT_NE(nullptr, interface);
ASSERT_FALSE(interface->GetMethods().empty());
EXPECT_EQ(interface->GetMethods()[0]->GetType().IsUtf8InCpp(), is_utf8);
- cpp_types_.typenames_.Reset();
+ typenames_.Reset();
}
}
TEST_F(AidlTest, VintfRequiresStructuredAndStability) {
AidlError error;
- auto parse_result = Parse("IFoo.aidl", "@VintfStability interface IFoo {}", &cpp_types_, &error);
+ auto parse_result = Parse("IFoo.aidl", "@VintfStability interface IFoo {}", typenames_,
+ Options::Language::CPP, &error);
ASSERT_EQ(AidlError::NOT_STRUCTURED, error);
ASSERT_EQ(nullptr, parse_result);
}
TEST_F(AidlTest, VintfRequiresStructured) {
AidlError error;
- auto parse_result = Parse("IFoo.aidl", "@VintfStability interface IFoo {}", &cpp_types_, &error,
- {"--stability", "vintf"});
+ auto parse_result = Parse("IFoo.aidl", "@VintfStability interface IFoo {}", typenames_,
+ Options::Language::CPP, &error, {"--stability", "vintf"});
ASSERT_EQ(AidlError::NOT_STRUCTURED, error);
ASSERT_EQ(nullptr, parse_result);
}
TEST_F(AidlTest, VintfRequiresSpecifiedStability) {
AidlError error;
- auto parse_result = Parse("IFoo.aidl", "@VintfStability interface IFoo {}", &cpp_types_, &error,
- {"--structured"});
+ auto parse_result = Parse("IFoo.aidl", "@VintfStability interface IFoo {}", typenames_,
+ Options::Language::CPP, &error, {"--structured"});
ASSERT_EQ(AidlError::NOT_STRUCTURED, error);
ASSERT_EQ(nullptr, parse_result);
}
TEST_F(AidlTest, ParsesStabilityAnnotations) {
AidlError error;
- auto parse_result = Parse("IFoo.aidl", "@VintfStability interface IFoo {}", &cpp_types_, &error,
- {"--structured", "--stability", "vintf"});
+ auto parse_result =
+ Parse("IFoo.aidl", "@VintfStability interface IFoo {}", typenames_, Options::Language::CPP,
+ &error, {"--structured", "--stability", "vintf"});
ASSERT_EQ(AidlError::OK, error);
ASSERT_NE(nullptr, parse_result);
const AidlInterface* interface = parse_result->AsInterface();
ASSERT_NE(nullptr, interface);
ASSERT_TRUE(interface->IsVintfStability());
- cpp_types_.typenames_.Reset();
+ typenames_.Reset();
}
TEST_F(AidlTest, ParsesJavaOnlyStableParcelable) {
@@ -348,6 +359,8 @@
"a/Foo.aidl", StringPrintf("package a; @JavaOnlyStableParcelable parcelable Foo;"));
EXPECT_EQ(0, ::android::aidl::compile_aidl(java_options, io_delegate_));
+ AddExpectedStderr(
+ "ERROR: a/Foo.aidl:1.48-52: @JavaOnlyStableParcelable supports only Java target.\n");
EXPECT_NE(0, ::android::aidl::compile_aidl(cpp_options, io_delegate_));
}
@@ -355,16 +368,20 @@
string oneway_method = "package a; interface IFoo { oneway void f(int a); }";
string oneway_interface =
"package a; oneway interface IBar { void f(int a); }";
- EXPECT_NE(nullptr, Parse("a/IFoo.aidl", oneway_method, &cpp_types_));
- EXPECT_NE(nullptr, Parse("a/IFoo.aidl", oneway_method, &java_types_));
- EXPECT_NE(nullptr, Parse("a/IBar.aidl", oneway_interface, &cpp_types_));
- EXPECT_NE(nullptr, Parse("a/IBar.aidl", oneway_interface, &java_types_));
+ EXPECT_NE(nullptr, Parse("a/IFoo.aidl", oneway_method, typenames_, Options::Language::CPP));
+ typenames_.Reset();
+ EXPECT_NE(nullptr, Parse("a/IFoo.aidl", oneway_method, typenames_, Options::Language::JAVA));
+ typenames_.Reset();
+ EXPECT_NE(nullptr, Parse("a/IBar.aidl", oneway_interface, typenames_, Options::Language::CPP));
+ typenames_.Reset();
+ EXPECT_NE(nullptr, Parse("a/IBar.aidl", oneway_interface, typenames_, Options::Language::JAVA));
}
TEST_F(AidlTest, AcceptsAnnotatedOnewayMethod) {
string oneway_method = "package a; interface IFoo { @UnsupportedAppUsage oneway void f(int a); }";
- EXPECT_NE(nullptr, Parse("a/IFoo.aidl", oneway_method, &cpp_types_));
- EXPECT_NE(nullptr, Parse("a/IFoo.aidl", oneway_method, &java_types_));
+ EXPECT_NE(nullptr, Parse("a/IFoo.aidl", oneway_method, typenames_, Options::Language::CPP));
+ typenames_.Reset();
+ EXPECT_NE(nullptr, Parse("a/IFoo.aidl", oneway_method, typenames_, Options::Language::JAVA));
}
TEST_F(AidlTest, WritesComments) {
@@ -374,7 +391,7 @@
" /* j */ @nullable String j();"
" /* k */ @UnsupportedAppUsage oneway void k(int a); }";
- auto parse_result = Parse("a/IFoo.aidl", foo_interface, &java_types_);
+ auto parse_result = Parse("a/IFoo.aidl", foo_interface, typenames_, Options::Language::JAVA);
EXPECT_NE(nullptr, parse_result);
EXPECT_EQ("/* foo */", parse_result->GetComments());
@@ -387,19 +404,20 @@
TEST_F(AidlTest, ParsesPreprocessedFile) {
string simple_content = "parcelable a.Foo;\ninterface b.IBar;";
io_delegate_.SetFileContents("path", simple_content);
- EXPECT_FALSE(java_types_.HasTypeByCanonicalName("a.Foo"));
- EXPECT_TRUE(parse_preprocessed_file(io_delegate_, "path", &java_types_, java_types_.typenames_));
- EXPECT_TRUE(java_types_.HasTypeByCanonicalName("a.Foo"));
- EXPECT_TRUE(java_types_.HasTypeByCanonicalName("b.IBar"));
+ EXPECT_FALSE(typenames_.ResolveTypename("a.Foo").second);
+ EXPECT_TRUE(parse_preprocessed_file(io_delegate_, "path", &typenames_));
+ EXPECT_TRUE(typenames_.ResolveTypename("a.Foo").second);
+ EXPECT_TRUE(typenames_.ResolveTypename("b.IBar").second);
}
TEST_F(AidlTest, ParsesPreprocessedFileWithWhitespace) {
string simple_content = "parcelable a.Foo;\n interface b.IBar ;\t";
io_delegate_.SetFileContents("path", simple_content);
- EXPECT_FALSE(java_types_.HasTypeByCanonicalName("a.Foo"));
- EXPECT_TRUE(parse_preprocessed_file(io_delegate_, "path", &java_types_, java_types_.typenames_));
- EXPECT_TRUE(java_types_.HasTypeByCanonicalName("a.Foo"));
- EXPECT_TRUE(java_types_.HasTypeByCanonicalName("b.IBar"));
+
+ EXPECT_FALSE(typenames_.ResolveTypename("a.Foo").second);
+ EXPECT_TRUE(parse_preprocessed_file(io_delegate_, "path", &typenames_));
+ EXPECT_TRUE(typenames_.ResolveTypename("a.Foo").second);
+ EXPECT_TRUE(typenames_.ResolveTypename("b.IBar").second);
}
TEST_F(AidlTest, PreferImportToPreprocessed) {
@@ -408,18 +426,17 @@
"interface IBar {}");
preprocessed_files_.push_back("preprocessed");
import_paths_.emplace("");
- auto parse_result = Parse(
- "p/IFoo.aidl", "package p; import one.IBar; interface IFoo {}",
- &java_types_);
+ auto parse_result = Parse("p/IFoo.aidl", "package p; import one.IBar; interface IFoo {}",
+ typenames_, Options::Language::JAVA);
EXPECT_NE(nullptr, parse_result);
+
// We expect to know about both kinds of IBar
- EXPECT_TRUE(java_types_.HasTypeByCanonicalName("one.IBar"));
- EXPECT_TRUE(java_types_.HasTypeByCanonicalName("another.IBar"));
+ EXPECT_TRUE(typenames_.ResolveTypename("one.IBar").second);
+ EXPECT_TRUE(typenames_.ResolveTypename("another.IBar").second);
// But if we request just "IBar" we should get our imported one.
AidlTypeSpecifier ambiguous_type(AIDL_LOCATION_HERE, "IBar", false, nullptr, "");
- const java::Type* type = java_types_.Find(ambiguous_type);
- ASSERT_TRUE(type);
- EXPECT_EQ("one.IBar", type->CanonicalName());
+ ambiguous_type.Resolve(typenames_);
+ EXPECT_EQ("one.IBar", ambiguous_type.GetName());
}
TEST_F(AidlTest, WritePreprocessedFile) {
@@ -471,10 +488,9 @@
io_delegate_.SetFileContents("p/Outer.aidl",
"package p; parcelable Outer.Inner;");
import_paths_.emplace("");
- auto parse_result = Parse(
- "p/IFoo.aidl",
- "package p; import p.Outer; interface IFoo { void f(in Inner c); }",
- &java_types_);
+ auto parse_result =
+ Parse("p/IFoo.aidl", "package p; import p.Outer; interface IFoo { void f(in Inner c); }",
+ typenames_, Options::Language::JAVA);
EXPECT_EQ(nullptr, parse_result);
}
@@ -482,10 +498,8 @@
io_delegate_.SetFileContents("preprocessed",
"parcelable p.Outer.Inner;");
preprocessed_files_.push_back("preprocessed");
- auto parse_result = Parse(
- "p/IFoo.aidl",
- "package p; interface IFoo { void f(in Inner c); }",
- &java_types_);
+ auto parse_result = Parse("p/IFoo.aidl", "package p; interface IFoo { void f(in Inner c); }",
+ typenames_, Options::Language::JAVA);
// TODO(wiley): This should actually return nullptr because we require
// the outer class name. However, for legacy reasons,
// this behavior must be maintained. b/17415692
@@ -519,23 +533,21 @@
auto parse_result =
Parse("p/IFoo.aidl",
"package p; import o.WhoKnowsWhat; interface IFoo { void f(in WhoKnowsWhat thisIs); }",
- &java_types_, &reported_error, {"--structured"});
+ typenames_, Options::Language::JAVA, &reported_error, {"--structured"});
EXPECT_EQ(nullptr, parse_result);
EXPECT_EQ(AidlError::NOT_STRUCTURED, reported_error);
}
TEST_F(AidlTest, FailOnDuplicateConstantNames) {
AidlError reported_error;
- EXPECT_EQ(nullptr,
- Parse("p/IFoo.aidl",
- R"(package p;
+ EXPECT_EQ(nullptr, Parse("p/IFoo.aidl",
+ R"(package p;
interface IFoo {
const String DUPLICATED = "d";
const int DUPLICATED = 1;
}
)",
- &cpp_types_,
- &reported_error));
+ typenames_, Options::Language::CPP, &reported_error));
EXPECT_EQ(AidlError::BAD_TYPE, reported_error);
}
@@ -549,7 +561,7 @@
parcelable StructuredParcelable {}
interface IBaz {}
)",
- &cpp_types_, &reported_error));
+ typenames_, Options::Language::CPP, &reported_error));
// Parse success is important for clear error handling even if the cases aren't
// actually supported in code generation.
EXPECT_EQ(AidlError::BAD_TYPE, reported_error);
@@ -557,35 +569,32 @@
TEST_F(AidlTest, FailOnNoDefinedTypes) {
AidlError reported_error;
- EXPECT_EQ(nullptr, Parse("p/IFoo.aidl", R"(package p;)", &cpp_types_, &reported_error));
+ EXPECT_EQ(nullptr, Parse("p/IFoo.aidl", R"(package p;)", typenames_, Options::Language::CPP,
+ &reported_error));
EXPECT_EQ(AidlError::PARSE_ERROR, reported_error);
}
TEST_F(AidlTest, FailOnMalformedConstHexValue) {
AidlError reported_error;
- EXPECT_EQ(nullptr,
- Parse("p/IFoo.aidl",
- R"(package p;
+ EXPECT_EQ(nullptr, Parse("p/IFoo.aidl",
+ R"(package p;
interface IFoo {
const int BAD_HEX_VALUE = 0xffffffffffffffffff;
}
)",
- &cpp_types_,
- &reported_error));
+ typenames_, Options::Language::CPP, &reported_error));
EXPECT_EQ(AidlError::BAD_TYPE, reported_error);
}
TEST_F(AidlTest, ParsePositiveConstHexValue) {
AidlError reported_error;
- auto cpp_parse_result =
- Parse("p/IFoo.aidl",
- R"(package p;
+ auto cpp_parse_result = Parse("p/IFoo.aidl",
+ R"(package p;
interface IFoo {
const int POSITIVE_HEX_VALUE = 0xf5;
}
)",
- &cpp_types_,
- &reported_error);
+ typenames_, Options::Language::CPP, &reported_error);
EXPECT_NE(nullptr, cpp_parse_result);
const AidlInterface* interface = cpp_parse_result->AsInterface();
ASSERT_NE(nullptr, interface);
@@ -597,15 +606,13 @@
TEST_F(AidlTest, ParseNegativeConstHexValue) {
AidlError reported_error;
- auto cpp_parse_result =
- Parse("p/IFoo.aidl",
- R"(package p;
+ auto cpp_parse_result = Parse("p/IFoo.aidl",
+ R"(package p;
interface IFoo {
const int NEGATIVE_HEX_VALUE = 0xffffffff;
}
)",
- &cpp_types_,
- &reported_error);
+ typenames_, Options::Language::CPP, &reported_error);
EXPECT_NE(nullptr, cpp_parse_result);
const AidlInterface* interface = cpp_parse_result->AsInterface();
ASSERT_NE(nullptr, interface);
@@ -624,12 +631,14 @@
const string input = "package p; import p.Outer; interface IFoo"
" { Outer.Inner get(); }";
- auto cpp_parse_result = Parse(input_path, input, &cpp_types_);
+ auto cpp_parse_result = Parse(input_path, input, typenames_, Options::Language::CPP);
EXPECT_NE(nullptr, cpp_parse_result);
- auto cpp_type = cpp_types_.FindTypeByCanonicalName("p.Outer.Inner");
- ASSERT_NE(nullptr, cpp_type);
+
+ auto pair = typenames_.ResolveTypename("p.Outer.Inner");
+ EXPECT_TRUE(pair.second);
// C++ uses "::" instead of "." to refer to a inner class.
- EXPECT_EQ("::p::Outer::Inner", cpp_type->CppType());
+ AidlTypeSpecifier nested_type(AIDL_LOCATION_HERE, "p.Outer.Inner", false, nullptr, "");
+ EXPECT_EQ("::p::Outer::Inner", cpp::CppNameOf(nested_type, typenames_));
}
TEST_F(AidlTest, UnderstandsNativeParcelables) {
@@ -639,24 +648,31 @@
import_paths_.emplace("");
const string input_path = "p/IFoo.aidl";
const string input = "package p; import p.Bar; interface IFoo { }";
-
- // C++ understands C++ specific stuff
- auto cpp_parse_result = Parse(input_path, input, &cpp_types_);
- EXPECT_NE(nullptr, cpp_parse_result);
- auto cpp_type = cpp_types_.FindTypeByCanonicalName("p.Bar");
- ASSERT_NE(nullptr, cpp_type);
- EXPECT_EQ("::p::Bar", cpp_type->CppType());
- set<string> headers;
- cpp_type->GetHeaders(&headers);
- EXPECT_EQ(1u, headers.size());
- EXPECT_EQ(1u, headers.count("baz/header"));
-
- // Java ignores C++ specific stuff
- auto java_parse_result = Parse(input_path, input, &java_types_);
- EXPECT_NE(nullptr, java_parse_result);
- auto java_type = java_types_.FindTypeByCanonicalName("p.Bar");
- ASSERT_NE(nullptr, java_type);
- EXPECT_EQ("p.Bar", java_type->InstantiableName());
+ {
+ // C++ understands C++ specific stuff
+ auto cpp_parse_result = Parse(input_path, input, typenames_, Options::Language::CPP);
+ EXPECT_NE(nullptr, cpp_parse_result);
+ auto pair = typenames_.ResolveTypename("p.Bar");
+ EXPECT_TRUE(pair.second);
+ AidlTypeSpecifier native_type(AIDL_LOCATION_HERE, "p.Bar", false, nullptr, "");
+ native_type.Resolve(typenames_);
+ EXPECT_EQ("::p::Bar", cpp::CppNameOf(native_type, typenames_));
+ set<string> headers;
+ cpp::AddHeaders(native_type, typenames_, headers);
+ EXPECT_EQ(1u, headers.size());
+ EXPECT_EQ(1u, headers.count("baz/header"));
+ }
+ typenames_.Reset();
+ {
+ // Java ignores C++ specific stuff
+ auto java_parse_result = Parse(input_path, input, typenames_, Options::Language::JAVA);
+ EXPECT_NE(nullptr, java_parse_result);
+ auto pair = typenames_.ResolveTypename("p.Bar");
+ EXPECT_TRUE(pair.second);
+ AidlTypeSpecifier native_type(AIDL_LOCATION_HERE, "p.Bar", false, nullptr, "");
+ native_type.Resolve(typenames_);
+ EXPECT_EQ("p.Bar", java::InstantiableJavaSignatureOf(native_type));
+ }
}
TEST_F(AidlTest, WritesCorrectDependencyFile) {
@@ -719,10 +735,11 @@
" List<int, List<String, bool>> foo(); }";
string nested_in_parcelable = "package a; parcelable IData {\n"
" List<int, List<String, bool>> foo;}";
- EXPECT_NE(nullptr, Parse("a/IFoo.aidl", nested_in_iface, &java_types_));
- EXPECT_NE(nullptr, Parse("a/IFoo.aidl", nested_in_iface, &cpp_types_));
- EXPECT_NE(nullptr, Parse("a/IFoo.aidl", nested_in_parcelable, &java_types_));
- EXPECT_NE(nullptr, Parse("a/IFoo.aidl", nested_in_parcelable, &cpp_types_));
+ EXPECT_NE(nullptr, Parse("a/IFoo.aidl", nested_in_iface, typenames_, Options::Language::JAVA));
+ EXPECT_NE(nullptr, Parse("a/IFoo.aidl", nested_in_iface, typenames_, Options::Language::CPP));
+ EXPECT_NE(nullptr, Parse("a/IFoo.aidl", nested_in_parcelable, typenames_,
+Options::Language::JAVA)); EXPECT_NE(nullptr, Parse("a/IFoo.aidl", nested_in_parcelable, typenames_,
+Options::Language::CPP));
}
*/
diff --git a/generate_cpp_unittest.cpp b/generate_cpp_unittest.cpp
index 8b4fc78..092e7cc 100644
--- a/generate_cpp_unittest.cpp
+++ b/generate_cpp_unittest.cpp
@@ -27,7 +27,6 @@
#include "os.h"
#include "tests/fake_io_delegate.h"
#include "tests/test_util.h"
-#include "type_cpp.h"
using ::android::aidl::test::FakeIoDelegate;
using ::android::base::StringPrintf;
@@ -1385,7 +1384,6 @@
protected:
ASTTest(const string& cmdline, const string& file_contents)
: options_(Options::From(cmdline)), file_contents_(file_contents) {
- types_.Init();
}
AidlInterface* ParseSingleInterface() {
@@ -1395,7 +1393,7 @@
vector<string> imported_files;
ImportResolver import_resolver{io_delegate_, options_.InputFiles().at(0), {"."}, {}};
AidlError err = ::android::aidl::internals::load_and_validate_aidl(
- options_.InputFiles().front(), options_, io_delegate_, &types_, &defined_types,
+ options_.InputFiles().front(), options_, io_delegate_, &typenames_, &defined_types,
&imported_files);
if (err != AidlError::OK) {
@@ -1423,7 +1421,7 @@
const Options options_;
const string file_contents_;
FakeIoDelegate io_delegate_;
- TypeNamespace types_;
+ AidlTypenames typenames_;
};
class ComplexTypeInterfaceASTTest : public ASTTest {
@@ -1439,44 +1437,42 @@
TEST_F(ComplexTypeInterfaceASTTest, GeneratesClientHeader) {
AidlInterface* interface = ParseSingleInterface();
ASSERT_NE(interface, nullptr);
- unique_ptr<Document> doc = internals::BuildClientHeader(types_.typenames_, *interface, options_);
+ unique_ptr<Document> doc = internals::BuildClientHeader(typenames_, *interface, options_);
Compare(doc.get(), kExpectedComplexTypeClientHeaderOutput);
}
TEST_F(ComplexTypeInterfaceASTTest, GeneratesClientSource) {
AidlInterface* interface = ParseSingleInterface();
ASSERT_NE(interface, nullptr);
- unique_ptr<Document> doc = internals::BuildClientSource(types_.typenames_, *interface, options_);
+ unique_ptr<Document> doc = internals::BuildClientSource(typenames_, *interface, options_);
Compare(doc.get(), kExpectedComplexTypeClientSourceOutput);
}
TEST_F(ComplexTypeInterfaceASTTest, GeneratesServerHeader) {
AidlInterface* interface = ParseSingleInterface();
ASSERT_NE(interface, nullptr);
- unique_ptr<Document> doc = internals::BuildServerHeader(types_.typenames_, *interface, options_);
+ unique_ptr<Document> doc = internals::BuildServerHeader(typenames_, *interface, options_);
Compare(doc.get(), kExpectedComplexTypeServerHeaderOutput);
}
TEST_F(ComplexTypeInterfaceASTTest, GeneratesServerSource) {
AidlInterface* interface = ParseSingleInterface();
ASSERT_NE(interface, nullptr);
- unique_ptr<Document> doc = internals::BuildServerSource(types_.typenames_, *interface, options_);
+ unique_ptr<Document> doc = internals::BuildServerSource(typenames_, *interface, options_);
Compare(doc.get(), kExpectedComplexTypeServerSourceOutput);
}
TEST_F(ComplexTypeInterfaceASTTest, GeneratesInterfaceHeader) {
AidlInterface* interface = ParseSingleInterface();
ASSERT_NE(interface, nullptr);
- unique_ptr<Document> doc =
- internals::BuildInterfaceHeader(types_.typenames_, *interface, options_);
+ unique_ptr<Document> doc = internals::BuildInterfaceHeader(typenames_, *interface, options_);
Compare(doc.get(), kExpectedComplexTypeInterfaceHeaderOutput);
}
TEST_F(ComplexTypeInterfaceASTTest, GeneratesInterfaceSource) {
AidlInterface* interface = ParseSingleInterface();
ASSERT_NE(interface, nullptr);
- unique_ptr<Document> doc =
- internals::BuildInterfaceSource(types_.typenames_, *interface, options_);
+ unique_ptr<Document> doc = internals::BuildInterfaceSource(typenames_, *interface, options_);
Compare(doc.get(), kExpectedComplexTypeInterfaceSourceOutput);
}
@@ -1492,14 +1488,14 @@
TEST_F(ComplexTypeInterfaceASTTestWithTrace, GeneratesClientSource) {
AidlInterface* interface = ParseSingleInterface();
ASSERT_NE(interface, nullptr);
- unique_ptr<Document> doc = internals::BuildClientSource(types_.typenames_, *interface, options_);
+ unique_ptr<Document> doc = internals::BuildClientSource(typenames_, *interface, options_);
Compare(doc.get(), kExpectedComplexTypeClientWithTraceSourceOutput);
}
TEST_F(ComplexTypeInterfaceASTTestWithTrace, GeneratesServerSource) {
AidlInterface* interface = ParseSingleInterface();
ASSERT_NE(interface, nullptr);
- unique_ptr<Document> doc = internals::BuildServerSource(types_.typenames_, *interface, options_);
+ unique_ptr<Document> doc = internals::BuildServerSource(typenames_, *interface, options_);
Compare(doc.get(), kExpectedComplexTypeServerWithTraceSourceOutput);
}
@@ -1523,8 +1519,7 @@
// Confirm that this is working correctly without I/O problems.
AidlInterface* interface = ParseSingleInterface();
ASSERT_NE(interface, nullptr);
- ASSERT_TRUE(
- GenerateCpp(options_.OutputFile(), options_, types_.typenames_, *interface, io_delegate_));
+ ASSERT_TRUE(GenerateCpp(options_.OutputFile(), options_, typenames_, *interface, io_delegate_));
}
TEST_F(IoErrorHandlingTest, HandlesBadHeaderWrite) {
@@ -1537,8 +1532,7 @@
StringPrintf("%s%c%s", kHeaderDir, OS_PATH_SEPARATOR,
kInterfaceHeaderRelPath);
io_delegate_.AddBrokenFilePath(header_path);
- ASSERT_FALSE(
- GenerateCpp(options_.OutputFile(), options_, types_.typenames_, *interface, io_delegate_));
+ ASSERT_FALSE(GenerateCpp(options_.OutputFile(), options_, typenames_, *interface, io_delegate_));
// We should never attempt to write the C++ file if we fail writing headers.
ASSERT_FALSE(io_delegate_.GetWrittenContents(kOutputPath, nullptr));
// We should remove partial results.
@@ -1552,8 +1546,7 @@
// Simulate issues closing the cpp file.
io_delegate_.AddBrokenFilePath(kOutputPath);
- ASSERT_FALSE(
- GenerateCpp(options_.OutputFile(), options_, types_.typenames_, *interface, io_delegate_));
+ ASSERT_FALSE(GenerateCpp(options_.OutputFile(), options_, typenames_, *interface, io_delegate_));
// We should remove partial results.
ASSERT_TRUE(io_delegate_.PathWasRemoved(kOutputPath));
}
diff --git a/generate_java_binder.cpp b/generate_java_binder.cpp
index af1452b..1581d48 100644
--- a/generate_java_binder.cpp
+++ b/generate_java_binder.cpp
@@ -17,6 +17,7 @@
#include "aidl.h"
#include "aidl_to_java.h"
#include "generate_java.h"
+#include "logging.h"
#include "options.h"
#include <stdio.h>
diff --git a/type_cpp.cpp b/type_cpp.cpp
deleted file mode 100644
index b9bd4b6..0000000
--- a/type_cpp.cpp
+++ /dev/null
@@ -1,502 +0,0 @@
-/*
- * Copyright (C) 2015, 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 "type_cpp.h"
-
-#include <algorithm>
-#include <iostream>
-#include <memory>
-#include <vector>
-
-#include <android-base/stringprintf.h>
-#include <android-base/strings.h>
-
-#include "logging.h"
-
-using std::string;
-using std::vector;
-
-using android::base::Join;
-using android::base::StringPrintf;
-
-namespace android {
-namespace aidl {
-namespace cpp {
-namespace {
-
-const char kNoPackage[] = "";
-const char kNoHeader[] = "";
-const char kNoValidMethod[] = "";
-Type* const kNoArrayType = nullptr;
-Type* const kNoNullableType = nullptr;
-
-class VoidType : public Type {
- public:
- VoidType() : Type(ValidatableType::KIND_BUILT_IN, kNoPackage, "void",
- {}, "void", kNoValidMethod, kNoValidMethod) {}
- ~VoidType() override = default;
- bool CanWriteToParcel() const override { return false; }
-}; // class VoidType
-
-class CppArrayType : public Type {
- public:
- CppArrayType(int kind, // from ValidatableType
- const std::string& package,
- const string& underlying_aidl_type,
- const string& cpp_header,
- const string& underlying_cpp_type,
- const string& underlying_cpp_type_nulllable,
- const string& read_method,
- const string& write_method,
- bool is_nullable,
- const string& src_file_name = "")
- : Type(kind, package,
- underlying_aidl_type + "[]",
- GetHeaders(is_nullable, cpp_header),
- GetCppType(is_nullable, underlying_cpp_type),
- read_method, write_method, kNoArrayType,
- (is_nullable)
- ? kNoNullableType
- // All arrays are nullable.
- : new CppArrayType(kind, package, underlying_aidl_type,
- cpp_header, underlying_cpp_type_nulllable,
- underlying_cpp_type_nulllable,
- read_method, write_method, true),
- src_file_name) {}
-
- private:
- static vector<string> GetHeaders(bool is_nullable, const string& cpp_header) {
- vector<string> result = {"vector"};
- if (is_nullable) {
- result.push_back("memory");
- }
- if (!cpp_header.empty()) {
- result.push_back(cpp_header);
- }
- return result;
- }
-
- static string GetCppType(bool is_nullable,
- const string& underlying_cpp_type) {
- if (is_nullable)
- return StringPrintf("::std::unique_ptr<::std::vector<%s>>",
- underlying_cpp_type.c_str());
- return StringPrintf("::std::vector<%s>",
- underlying_cpp_type.c_str());
- }
-
- DISALLOW_COPY_AND_ASSIGN(CppArrayType);
-}; // class CppArrayType
-
-class PrimitiveType : public Type {
- public:
- PrimitiveType(const std::string& aidl_type,
- const std::string& header,
- const std::string& cpp_type,
- const std::string& read_method,
- const std::string& write_method,
- const std::string& read_array_method,
- const std::string& write_array_method)
- : Type(ValidatableType::KIND_BUILT_IN, kNoPackage, aidl_type, {header},
- cpp_type, read_method, write_method,
- new CppArrayType(ValidatableType::KIND_BUILT_IN, kNoPackage,
- aidl_type, header, cpp_type, cpp_type,
- read_array_method, write_array_method,
- false)) {}
-
- ~PrimitiveType() override = default;
- bool IsCppPrimitive() const override { return true; }
-
- private:
- DISALLOW_COPY_AND_ASSIGN(PrimitiveType);
-}; // class PrimitiveType
-
-// Unfortunately, bytes in Java are signed. However, most C authors would
-// say that a byte is not in fact signed. Compromise: customize this otherwise
-// normal primitive to use signed single bytes, but unsigned byte arrays.
-class ByteType : public Type {
- public:
- ByteType()
- : Type(ValidatableType::KIND_BUILT_IN, kNoPackage, "byte",
- {"cstdint"}, "int8_t", "readByte", "writeByte",
- new CppArrayType(ValidatableType::KIND_BUILT_IN, kNoPackage,
- "byte", "cstdint", "uint8_t", "uint8_t",
- "readByteVector", "writeByteVector",
- false)) {}
-
- ~ByteType() override = default;
- bool IsCppPrimitive() const override { return true; }
-
- private:
- DISALLOW_COPY_AND_ASSIGN(ByteType);
-}; // class PrimitiveType
-
-static string GetCppHeader(const AidlDefinedType& defined_type) {
- vector<string> name = defined_type.GetSplitPackage();
- name.push_back(defined_type.GetName());
- return Join(name, '/') + ".h";
-}
-
-class BinderType : public Type {
- public:
- BinderType(const AidlInterface& interface, const std::string& src_file_name)
- : BinderType(interface, src_file_name,
- new BinderType(interface, src_file_name, kNoNullableType,
- "readNullableStrongBinder"),
- "readStrongBinder") {}
- ~BinderType() override = default;
-
- string WriteCast(const string& val) const override {
- return write_cast_ + "(" + val + ")";
- }
-
- private:
- BinderType(const AidlInterface& interface, const std::string& src_file_name, Type* nullable_type,
- const std::string& read)
- : Type(ValidatableType::KIND_GENERATED, interface.GetPackage(), interface.GetName(),
- {GetCppHeader(interface)}, GetCppName(interface), read, "writeStrongBinder",
- kNoArrayType, nullable_type, src_file_name),
- write_cast_(GetRawCppName(interface) + "::asBinder") {}
-
- static string GetCppName(const AidlInterface& interface) {
- return "::android::sp<" + GetRawCppName(interface) + ">";
- }
-
- static string GetRawCppName(const AidlInterface& interface) {
- vector<string> name = interface.GetSplitPackage();
- string ret;
-
- name.push_back(interface.GetName());
-
- for (const auto& term : name) {
- ret += "::" + term;
- }
-
- return ret;
- }
-
- std::string write_cast_;
-};
-
-class NullableParcelableType : public Type {
- public:
- NullableParcelableType(const AidlParcelable& parcelable, const std::string& cpp_header,
- const std::string& src_file_name)
- : Type(ValidatableType::KIND_PARCELABLE, parcelable.GetPackage(), parcelable.GetName(),
- {cpp_header}, GetCppName(parcelable), "readParcelable", "writeNullableParcelable",
- kNoArrayType, kNoNullableType, src_file_name) {}
- ~NullableParcelableType() override = default;
-
- private:
- static string GetCppName(const AidlParcelable& parcelable) {
- return "::std::unique_ptr<::" + Join(parcelable.GetSplitPackage(), "::") +
- "::" + parcelable.GetCppName() + ">";
- }
-};
-
-class ParcelableType : public Type {
- public:
- ParcelableType(const AidlParcelable& parcelable, const std::string& cpp_header,
- const std::string& src_file_name)
- : Type(ValidatableType::KIND_PARCELABLE, parcelable.GetPackage(), parcelable.GetName(),
- {cpp_header}, GetCppName(parcelable), "readParcelable", "writeParcelable",
- new CppArrayType(ValidatableType::KIND_PARCELABLE, parcelable.GetPackage(),
- parcelable.GetName(), cpp_header, GetCppName(parcelable),
- GetCppName(parcelable), "readParcelableVector",
- "writeParcelableVector", false, src_file_name),
- new NullableParcelableType(parcelable, cpp_header, src_file_name), src_file_name) {}
- ~ParcelableType() override = default;
-
- private:
- static string GetCppName(const AidlParcelable& parcelable) {
- std::vector<std::string> components = parcelable.GetSplitPackage();
- components.push_back(parcelable.GetCppName());
-
- return "::" + Join(components, "::");
- }
-};
-
-class NullableStringListType : public Type {
- public:
- NullableStringListType()
- : Type(ValidatableType::KIND_BUILT_IN,
- "java.util", "List<" + string(kStringCanonicalName) + ">",
- {"utils/String16.h", "memory", "vector"},
- "::std::unique_ptr<::std::vector<std::unique_ptr<::android::String16>>>",
- "readString16Vector", "writeString16Vector") {}
- ~NullableStringListType() override = default;
-
- private:
- DISALLOW_COPY_AND_ASSIGN(NullableStringListType);
-}; // class NullableStringListType
-
-class StringListType : public Type {
- public:
- StringListType()
- : Type(ValidatableType::KIND_BUILT_IN,
- "java.util", "List<" + string(kStringCanonicalName) + ">",
- {"utils/String16.h", "vector"},
- "::std::vector<::android::String16>",
- "readString16Vector", "writeString16Vector",
- kNoArrayType, new NullableStringListType()) {}
- ~StringListType() override = default;
-
- private:
- DISALLOW_COPY_AND_ASSIGN(StringListType);
-}; // class StringListType
-
-class NullableUtf8InCppStringListType : public Type {
- public:
- NullableUtf8InCppStringListType()
- : Type(ValidatableType::KIND_BUILT_IN,
- "java.util", "List<" + string(kUtf8InCppStringCanonicalName) + ">",
- {"memory", "string", "vector"},
- "::std::unique_ptr<::std::vector<std::unique_ptr<::std::string>>>",
- "readUtf8VectorFromUtf16Vector", "writeUtf8VectorAsUtf16Vector") {}
- ~NullableUtf8InCppStringListType() override = default;
-
- private:
- DISALLOW_COPY_AND_ASSIGN(NullableUtf8InCppStringListType);
-}; // class NullableUtf8InCppStringListType
-
-class Utf8InCppStringListType : public Type {
- public:
- Utf8InCppStringListType()
- : Type(ValidatableType::KIND_BUILT_IN,
- "java.util", "List<" + string(kUtf8InCppStringCanonicalName) + ">",
- {"string", "vector"},
- "::std::vector<::std::string>",
- "readUtf8VectorFromUtf16Vector", "writeUtf8VectorAsUtf16Vector",
- kNoArrayType, new NullableUtf8InCppStringListType()) {}
- ~Utf8InCppStringListType() override = default;
-
- private:
- DISALLOW_COPY_AND_ASSIGN(Utf8InCppStringListType);
-}; // class Utf8InCppStringListType
-
-class NullableBinderListType : public Type {
- public:
- NullableBinderListType()
- : Type(ValidatableType::KIND_BUILT_IN, "java.util",
- "List<android.os.IBinder>", {"binder/IBinder.h", "vector"},
- "::std::unique_ptr<::std::vector<::android::sp<::android::IBinder>>>",
- "readStrongBinderVector", "writeStrongBinderVector") {}
- ~NullableBinderListType() override = default;
-
- private:
- DISALLOW_COPY_AND_ASSIGN(NullableBinderListType);
-}; // class NullableBinderListType
-
-class BinderListType : public Type {
- public:
- BinderListType()
- : Type(ValidatableType::KIND_BUILT_IN, "java.util",
- "List<android.os.IBinder>", {"binder/IBinder.h", "vector"},
- "::std::vector<::android::sp<::android::IBinder>>",
- "readStrongBinderVector", "writeStrongBinderVector",
- kNoArrayType, new NullableBinderListType()) {}
- ~BinderListType() override = default;
-
- private:
- DISALLOW_COPY_AND_ASSIGN(BinderListType);
-}; // class BinderListType
-
-} // namespace
-
-Type::Type(int kind,
- const std::string& package,
- const std::string& aidl_type,
- const vector<string>& headers,
- const string& cpp_type,
- const string& read_method,
- const string& write_method,
- Type* array_type,
- Type* nullable_type,
- const string& src_file_name,
- int line)
- : ValidatableType(kind, package, aidl_type, src_file_name, line),
- headers_(headers),
- aidl_type_(aidl_type),
- cpp_type_(cpp_type),
- parcel_read_method_(read_method),
- parcel_write_method_(write_method),
- array_type_(array_type),
- nullable_type_(nullable_type) {}
-
-bool Type::CanWriteToParcel() const { return true; }
-
-void TypeNamespace::Init() {
- Add(std::make_unique<ByteType>());
- Add(std::make_unique<PrimitiveType>("int", "cstdint", "int32_t", "readInt32", "writeInt32",
- "readInt32Vector", "writeInt32Vector"));
- Add(std::make_unique<PrimitiveType>("long", "cstdint", "int64_t", "readInt64", "writeInt64",
- "readInt64Vector", "writeInt64Vector"));
- Add(std::make_unique<PrimitiveType>("float", kNoHeader, "float", "readFloat", "writeFloat",
- "readFloatVector", "writeFloatVector"));
- Add(std::make_unique<PrimitiveType>("double", kNoHeader, "double", "readDouble", "writeDouble",
- "readDoubleVector", "writeDoubleVector"));
- Add(std::make_unique<PrimitiveType>("boolean", kNoHeader, "bool", "readBool", "writeBool",
- "readBoolVector", "writeBoolVector"));
- // C++11 defines the char16_t type as a built in for Unicode characters.
- Add(std::make_unique<PrimitiveType>("char", kNoHeader, "char16_t", "readChar", "writeChar",
- "readCharVector", "writeCharVector"));
-
- Type* string_array_type = new CppArrayType(
- ValidatableType::KIND_BUILT_IN, "java.lang", "String",
- "utils/String16.h", "::android::String16",
- "::std::unique_ptr<::android::String16>", "readString16Vector",
- "writeString16Vector", false);
-
- Type* nullable_string_type =
- new Type(ValidatableType::KIND_BUILT_IN, "java.lang", "String",
- {"memory", "utils/String16.h"}, "::std::unique_ptr<::android::String16>",
- "readString16", "writeString16");
-
- AddAndSetMember(&string_type_,
- std::make_unique<Type>(ValidatableType::KIND_BUILT_IN, "java.lang", "String",
- std::vector<std::string>{"utils/String16.h"},
- "::android::String16", "readString16", "writeString16",
- string_array_type, nullable_string_type));
-
- using ::android::aidl::kAidlReservedTypePackage;
- using ::android::aidl::kUtf8InCppStringClass;
-
- // This type is a Utf16 string in the parcel, but deserializes to
- // a std::string in Utf8 format when we use it in C++.
- Type* cpp_utf8_string_array = new CppArrayType(
- ValidatableType::KIND_BUILT_IN,
- kAidlReservedTypePackage, kUtf8InCppStringClass,
- "string", "::std::string", "::std::unique_ptr<::std::string>",
- "readUtf8VectorFromUtf16Vector", "writeUtf8VectorAsUtf16Vector",
- false);
- Type* nullable_cpp_utf8_string_type =
- new Type(ValidatableType::KIND_BUILT_IN, kAidlReservedTypePackage, kUtf8InCppStringClass,
- std::vector<std::string>{"string", "memory"}, "::std::unique_ptr<::std::string>",
- "readUtf8FromUtf16", "writeUtf8AsUtf16");
- Add(std::make_unique<Type>(ValidatableType::KIND_BUILT_IN, kAidlReservedTypePackage,
- kUtf8InCppStringClass, std::vector<std::string>{"string"},
- "::std::string", "readUtf8FromUtf16", "writeUtf8AsUtf16",
- cpp_utf8_string_array, nullable_cpp_utf8_string_type));
-
- Type* nullable_ibinder = new Type(
- ValidatableType::KIND_BUILT_IN, "android.os", "IBinder",
- {"binder/IBinder.h"}, "::android::sp<::android::IBinder>",
- "readNullableStrongBinder", "writeStrongBinder");
-
- AddAndSetMember(&ibinder_type_,
- std::make_unique<Type>(ValidatableType::KIND_BUILT_IN, "android.os", "IBinder",
- std::vector<std::string>{"binder/IBinder.h"},
- "::android::sp<::android::IBinder>", "readStrongBinder",
- "writeStrongBinder", kNoArrayType, nullable_ibinder));
-
- Add(std::make_unique<BinderListType>());
- Add(std::make_unique<StringListType>());
- Add(std::make_unique<Utf8InCppStringListType>());
-
- Type* fd_vector_type = new CppArrayType(
- ValidatableType::KIND_BUILT_IN, kNoPackage, "FileDescriptor",
- "android-base/unique_fd.h",
- "::android::base::unique_fd", "::android::base::unique_fd",
- "readUniqueFileDescriptorVector", "writeUniqueFileDescriptorVector",
- false);
-
- Add(std::make_unique<Type>(ValidatableType::KIND_BUILT_IN, kNoPackage, "FileDescriptor",
- std::vector<std::string>{"android-base/unique_fd.h"},
- "::android::base::unique_fd", "readUniqueFileDescriptor",
- "writeUniqueFileDescriptor", fd_vector_type));
-
- Type* pfd_vector_type =
- new CppArrayType(ValidatableType::KIND_BUILT_IN, "android.os", "ParcelFileDescriptor",
- "binder/ParcelFileDescriptor.h", "::android::os::ParcelFileDescriptor",
- "::android::os::ParcelFileDescriptor", "readParcelableVector",
- "writeParcelableVector", false);
-
- Type* nullable_pfd_type =
- new Type(ValidatableType::KIND_BUILT_IN, "android.os", "ParcelFileDescriptor",
- std::vector<std::string>{"memory", "binder/ParcelFileDescriptor.h"},
- "::std::unique_ptr<::android::os::ParcelFileDescriptor>", "readParcelable",
- "writeNullableParcelable");
-
- Add(std::make_unique<Type>(ValidatableType::KIND_BUILT_IN, "android.os", "ParcelFileDescriptor",
- std::vector<std::string>{"binder/ParcelFileDescriptor.h"},
- "::android::os::ParcelFileDescriptor", "readParcelable",
- "writeParcelable", pfd_vector_type, nullable_pfd_type));
-
- // Qualify VoidType so we don't get collisions with the VoidType method
- AddAndSetMember(&void_type_, std::make_unique<class VoidType>());
-}
-
-bool TypeNamespace::AddParcelableType(const AidlParcelable& p, const std::string& filename) {
- const std::string cpp_header = p.AsStructuredParcelable() ? GetCppHeader(p) : p.GetCppHeader();
- if (p.IsStableParcelable()) {
- AIDL_ERROR(p) << "@JavaOnlyStableParcelable supports only Java target.";
- return false;
- }
- if (cpp_header.empty()) {
- AIDL_ERROR(p) << "Parcelable " << p.GetCanonicalName() << " has no C++ header defined.";
- return false;
- }
-
- Add(std::make_unique<ParcelableType>(p, cpp_header, filename));
- return true;
-}
-
-bool TypeNamespace::AddBinderType(const AidlInterface& b, const std::string& filename) {
- Add(std::make_unique<BinderType>(b, filename));
- return true;
-}
-
-bool TypeNamespace::AddListType(const std::string& type_name) {
- const Type* contained_type = FindTypeByCanonicalName(type_name);
- if (!contained_type) {
- LOG(ERROR) << "Cannot create List<" << type_name << "> because contained "
- "type cannot be found or is invalid.";
- return false;
- }
- if (contained_type->IsCppPrimitive()) {
- LOG(ERROR) << "Cannot create List<" << type_name << "> because contained "
- "type is a primitive in Java and Java List cannot hold "
- "primitives.";
- return false;
- }
-
- if (contained_type->CanonicalName() == kStringCanonicalName ||
- contained_type->CanonicalName() == kUtf8InCppStringCanonicalName ||
- contained_type == IBinderType()) {
- return true;
- }
-
- // TODO Support lists of parcelables b/23600712
-
- LOG(ERROR) << "aidl-cpp does not yet support List<" << type_name << ">";
- return false;
-}
-
-bool TypeNamespace::AddMapType(const std::string& /* key_type_name */,
- const std::string& /* value_type_name */) {
- // TODO Support list types b/25242025
- LOG(ERROR) << "aidl does not implement support for typed maps!";
- return false;
-}
-
-const ValidatableType* TypeNamespace::GetArgType(const AidlArgument& a, int arg_index,
- const AidlDefinedType& context) const {
- return ::android::aidl::TypeNamespace::GetArgType(a, arg_index, context);
-}
-
-} // namespace cpp
-} // namespace aidl
-} // namespace android
diff --git a/type_cpp.h b/type_cpp.h
deleted file mode 100644
index a27132b..0000000
--- a/type_cpp.h
+++ /dev/null
@@ -1,118 +0,0 @@
-/*
- * Copyright (C) 2015, 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.
- */
-
-#pragma once
-
-#include <memory>
-#include <string>
-#include <set>
-#include <vector>
-
-#include <android-base/macros.h>
-
-#include "type_namespace.h"
-
-namespace android {
-namespace aidl {
-namespace cpp {
-
-class Type : public ValidatableType {
- public:
- Type(int kind, // from ValidatableType
- const std::string& package,
- const std::string& aidl_type,
- const std::vector<std::string>& header,
- const std::string& cpp_type,
- const std::string& read_method,
- const std::string& write_method,
- Type* array_type = nullptr,
- Type* nullable_type = nullptr,
- const std::string& src_file_name = "",
- int line = -1);
- virtual ~Type() = default;
-
- // overrides of ValidatableType
- bool CanWriteToParcel() const override;
-
- const Type* ArrayType() const override { return array_type_.get(); }
- const Type* NullableType() const override { return nullable_type_.get(); }
- std::string CppType() const { return cpp_type_; }
- const std::string& ReadFromParcelMethod() const {
- return parcel_read_method_;
- }
- const std::string& WriteToParcelMethod() const {
- return parcel_write_method_;
- }
-
- void GetHeaders(std::set<std::string>* headers) const {
- for (const std::string& header : headers_) {
- if (!header.empty()) {
- headers->insert(header);
- }
- }
- }
- virtual bool IsCppPrimitive() const { return false; }
- virtual std::string WriteCast(const std::string& value) const {
- return value;
- }
-
- private:
- // |headers| are the headers we must include to use this type
- const std::vector<std::string> headers_;
- // |aidl_type| is what we find in the yacc generated AST (e.g. "int").
- const std::string aidl_type_;
- // |cpp_type| is what we use in the generated C++ code (e.g. "int32_t").
- const std::string cpp_type_;
- const std::string parcel_read_method_;
- const std::string parcel_write_method_;
-
- const std::unique_ptr<Type> array_type_;
- const std::unique_ptr<Type> nullable_type_;
-
- DISALLOW_COPY_AND_ASSIGN(Type);
-}; // class Type
-
-class TypeNamespace : public ::android::aidl::LanguageTypeNamespace<Type> {
- public:
- TypeNamespace() = default;
- virtual ~TypeNamespace() = default;
-
- void Init() override;
- bool AddParcelableType(const AidlParcelable& p,
- const std::string& filename) override;
- bool AddBinderType(const AidlInterface& b,
- const std::string& filename) override;
- bool AddListType(const std::string& type_name) override;
- bool AddMapType(const std::string& key_type_name,
- const std::string& value_type_name) override;
-
- const ValidatableType* GetArgType(const AidlArgument& a, int arg_index,
- const AidlDefinedType& context) const override;
-
- const Type* VoidType() const { return void_type_; }
- const Type* IBinderType() const { return ibinder_type_; }
-
- private:
- const Type* void_type_ = nullptr;
- const Type* string_type_ = nullptr;
- const Type* ibinder_type_ = nullptr;
-
- DISALLOW_COPY_AND_ASSIGN(TypeNamespace);
-}; // class TypeNamespace
-
-} // namespace cpp
-} // namespace aidl
-} // namespace android
diff --git a/type_cpp_unittest.cpp b/type_cpp_unittest.cpp
deleted file mode 100644
index b098086..0000000
--- a/type_cpp_unittest.cpp
+++ /dev/null
@@ -1,71 +0,0 @@
-/*
- * Copyright (C) 2015, 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 <memory>
-#include <string>
-
-#include <gtest/gtest.h>
-
-#include "type_cpp.h"
-
-using std::string;
-using std::unique_ptr;
-
-namespace android {
-namespace aidl {
-namespace cpp {
-
-namespace {
-
-string kParcelableDotName = "Outer.Inner";
-string kParcelableColonName = "Outer::Inner";
-
-} // namespace
-
-class CppTypeNamespaceTest : public ::testing::Test {
- protected:
- void SetUp() override {
- types_.Init();
- }
- TypeNamespace types_;
-};
-
-TEST_F(CppTypeNamespaceTest, HasSomeBasicTypes) {
- EXPECT_TRUE(types_.HasTypeByCanonicalName("byte"));
- EXPECT_TRUE(types_.HasTypeByCanonicalName("int"));
- EXPECT_TRUE(types_.HasTypeByCanonicalName("long"));
- EXPECT_TRUE(types_.HasTypeByCanonicalName("float"));
- EXPECT_TRUE(types_.HasTypeByCanonicalName("double"));
- EXPECT_TRUE(types_.HasTypeByCanonicalName("boolean"));
- EXPECT_TRUE(types_.HasTypeByCanonicalName("char"));
- EXPECT_TRUE(types_.HasTypeByCanonicalName("String"));
-}
-
-TEST_F(CppTypeNamespaceTest, SupportsListString) {
- EXPECT_TRUE(
- types_.HasTypeByCanonicalName("java.util.List<java.lang.String>"));
-}
-
-TEST_F(CppTypeNamespaceTest, SupportsNestedParcelableClass) {
- unique_ptr<AidlParcelable> parcelable(new AidlParcelable(
- AIDL_LOCATION_HERE, new AidlQualifiedName(AIDL_LOCATION_HERE, kParcelableDotName, ""),
- {"a", "goog"}, ""));
- EXPECT_EQ(parcelable->GetCppName(), kParcelableColonName);
-}
-
-} // namespace cpp
-} // namespace aidl
-} // namespace android
diff --git a/type_java.cpp b/type_java.cpp
deleted file mode 100644
index 5f5f9dc..0000000
--- a/type_java.cpp
+++ /dev/null
@@ -1,351 +0,0 @@
-/*
- * Copyright (C) 2015, 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 "type_java.h"
-
-#include <sys/types.h>
-#include <memory>
-
-#include <android-base/strings.h>
-
-#include "aidl_language.h"
-#include "logging.h"
-
-using std::string;
-
-namespace android {
-namespace aidl {
-namespace java {
-
-// ================================================================
-
-Type::Type(const JavaTypeNamespace* types, const string& name, int kind, bool canWriteToParcel)
- : Type(types, "", name, kind, canWriteToParcel, "", -1) {}
-
-Type::Type(const JavaTypeNamespace* types, const string& package, const string& name, int kind,
- bool canWriteToParcel, const string& declFile, int declLine)
- : ValidatableType(kind, package, name, declFile, declLine),
- m_types(types),
- m_javaType((package.empty()) ? name : package + "." + name),
- m_canWriteToParcel(canWriteToParcel) {}
-
-string Type::InstantiableName() const { return JavaType(); }
-
-Expression* Type::BuildWriteToParcelFlags(int flags) const {
- if (flags == 0) {
- return new LiteralExpression("0");
- }
- if ((flags & PARCELABLE_WRITE_RETURN_VALUE) != 0) {
- return new FieldVariable(m_types->ParcelableInterfaceType()->JavaType(),
- "PARCELABLE_WRITE_RETURN_VALUE");
- }
- return new LiteralExpression("0");
-}
-
-// ================================================================
-
-BasicType::BasicType(const JavaTypeNamespace* types, const string& name,
- const string& marshallParcel, const string& unmarshallParcel,
- const string& writeArrayParcel, const string& createArrayParcel,
- const string& readArrayParcel)
- : Type(types, name, ValidatableType::KIND_BUILT_IN, true),
- m_marshallParcel(marshallParcel),
- m_unmarshallParcel(unmarshallParcel) {
- m_array_type.reset(new BasicArrayType(types, name, writeArrayParcel,
- createArrayParcel, readArrayParcel));
-}
-
-BasicArrayType::BasicArrayType(const JavaTypeNamespace* types, const string& name,
- const string& writeArrayParcel, const string& createArrayParcel,
- const string& readArrayParcel)
- : Type(types, name, ValidatableType::KIND_BUILT_IN, true),
- m_writeArrayParcel(writeArrayParcel),
- m_createArrayParcel(createArrayParcel),
- m_readArrayParcel(readArrayParcel) {}
-
-// ================================================================
-
-FileDescriptorType::FileDescriptorType(const JavaTypeNamespace* types)
- : Type(types, "java.io", "FileDescriptor", ValidatableType::KIND_BUILT_IN, true) {
- m_array_type.reset(new FileDescriptorArrayType(types));
-}
-
-FileDescriptorArrayType::FileDescriptorArrayType(const JavaTypeNamespace* types)
- : Type(types, "java.io", "FileDescriptor", ValidatableType::KIND_BUILT_IN, true) {}
-
-// ================================================================
-
-ParcelFileDescriptorType::ParcelFileDescriptorType(const JavaTypeNamespace* types)
- : Type(types, "android.os", "ParcelFileDescriptor", ValidatableType::KIND_BUILT_IN, true) {
- m_array_type.reset(new ParcelFileDescriptorArrayType(types));
-}
-
-ParcelFileDescriptorArrayType::ParcelFileDescriptorArrayType(const JavaTypeNamespace* types)
- : Type(types, "android.os", "ParcelFileDescriptor", ValidatableType::KIND_BUILT_IN, true) {}
-
-// ================================================================
-
-BooleanType::BooleanType(const JavaTypeNamespace* types)
- : Type(types, "boolean", ValidatableType::KIND_BUILT_IN, true) {
- m_array_type.reset(new BooleanArrayType(types));
-}
-
-BooleanArrayType::BooleanArrayType(const JavaTypeNamespace* types)
- : Type(types, "boolean", ValidatableType::KIND_BUILT_IN, true) {}
-
-// ================================================================
-
-CharType::CharType(const JavaTypeNamespace* types)
- : Type(types, "char", ValidatableType::KIND_BUILT_IN, true) {
- m_array_type.reset(new CharArrayType(types));
-}
-
-CharArrayType::CharArrayType(const JavaTypeNamespace* types)
- : Type(types, "char", ValidatableType::KIND_BUILT_IN, true) {}
-
-// ================================================================
-
-StringType::StringType(const JavaTypeNamespace* types, const std::string& package,
- const std::string& class_name)
- : Type(types, package, class_name, ValidatableType::KIND_BUILT_IN, true) {
- m_array_type.reset(new StringArrayType(types));
-}
-
-StringArrayType::StringArrayType(const JavaTypeNamespace* types)
- : Type(types, "java.lang", "String", ValidatableType::KIND_BUILT_IN, true) {}
-
-// ================================================================
-
-CharSequenceType::CharSequenceType(const JavaTypeNamespace* types)
- : Type(types, "java.lang", "CharSequence", ValidatableType::KIND_BUILT_IN, true) {}
-
-// ================================================================
-
-RemoteExceptionType::RemoteExceptionType(const JavaTypeNamespace* types)
- : Type(types, "android.os", "RemoteException", ValidatableType::KIND_BUILT_IN, false) {}
-
-// ================================================================
-
-RuntimeExceptionType::RuntimeExceptionType(const JavaTypeNamespace* types)
- : Type(types, "java.lang", "RuntimeException", ValidatableType::KIND_BUILT_IN, false) {}
-
-// ================================================================
-
-IBinderType::IBinderType(const JavaTypeNamespace* types)
- : Type(types, "android.os", "IBinder", ValidatableType::KIND_BUILT_IN, true) {
- m_array_type.reset(new IBinderArrayType(types));
-}
-
-IBinderArrayType::IBinderArrayType(const JavaTypeNamespace* types)
- : Type(types, "android.os", "IBinder", ValidatableType::KIND_BUILT_IN, true) {}
-
-// ================================================================
-
-IInterfaceType::IInterfaceType(const JavaTypeNamespace* types)
- : Type(types, "android.os", "IInterface", ValidatableType::KIND_BUILT_IN, false) {}
-
-// ================================================================
-
-BinderType::BinderType(const JavaTypeNamespace* types)
- : Type(types, "android.os", "Binder", ValidatableType::KIND_BUILT_IN, false) {}
-
-// ================================================================
-
-BinderProxyType::BinderProxyType(const JavaTypeNamespace* types)
- : Type(types, "android.os", "BinderProxy", ValidatableType::KIND_BUILT_IN, false) {}
-
-// ================================================================
-
-ParcelType::ParcelType(const JavaTypeNamespace* types)
- : Type(types, "android.os", "Parcel", ValidatableType::KIND_BUILT_IN, false) {}
-
-// ================================================================
-
-ParcelableInterfaceType::ParcelableInterfaceType(const JavaTypeNamespace* types)
- : Type(types, "android.os", "Parcelable", ValidatableType::KIND_BUILT_IN, false) {}
-
-// ================================================================
-
-MapType::MapType(const JavaTypeNamespace* types)
- : Type(types, "java.util", "Map", ValidatableType::KIND_BUILT_IN, true) {}
-
-// ================================================================
-
-ListType::ListType(const JavaTypeNamespace* types)
- : Type(types, "java.util", "List", ValidatableType::KIND_BUILT_IN, true) {}
-
-string ListType::InstantiableName() const { return "java.util.ArrayList"; }
-
-// ================================================================
-
-UserDataType::UserDataType(const JavaTypeNamespace* types, const string& package,
- const string& name, bool builtIn, bool canWriteToParcel,
- const string& declFile, int declLine)
- : Type(types, package, name,
- builtIn ? ValidatableType::KIND_BUILT_IN : ValidatableType::KIND_PARCELABLE,
- canWriteToParcel, declFile, declLine) {
- m_array_type.reset(new UserDataArrayType(types, package, name, builtIn,
- canWriteToParcel, declFile,
- declLine));
-}
-
-UserDataArrayType::UserDataArrayType(const JavaTypeNamespace* types, const string& package,
- const string& name, bool builtIn, bool canWriteToParcel,
- const string& declFile, int declLine)
- : Type(types, package, name,
- builtIn ? ValidatableType::KIND_BUILT_IN : ValidatableType::KIND_PARCELABLE,
- canWriteToParcel, declFile, declLine) {}
-
-// ================================================================
-
-InterfaceType::InterfaceType(const JavaTypeNamespace* types, const string& package,
- const string& name, bool builtIn, const string& declFile, int declLine,
- const Type* stub, const Type* proxy, const Type* defaultImpl)
- : Type(types, package, name,
- builtIn ? ValidatableType::KIND_BUILT_IN : ValidatableType::KIND_INTERFACE, true,
- declFile, declLine),
- stub_(stub),
- proxy_(proxy),
- defaultImpl_(defaultImpl) {}
-
-// ================================================================
-
-GenericListType::GenericListType(const JavaTypeNamespace* types, const Type* contained_type)
- : Type(types, "java.util", "List<" + contained_type->CanonicalName() + ">",
- ValidatableType::KIND_BUILT_IN, true),
- m_contained_type(contained_type) {}
-
-string GenericListType::InstantiableName() const {
- return "java.util.ArrayList<" + m_contained_type->JavaType() + ">";
-}
-
-// ================================================================
-
-ClassLoaderType::ClassLoaderType(const JavaTypeNamespace* types)
- : Type(types, "java.lang", "ClassLoader", ValidatableType::KIND_BUILT_IN, false) {}
-
-// ================================================================
-
-void JavaTypeNamespace::Init() {
- Add(std::make_unique<BasicType>(this, "void", "XXX", "XXX", "XXX", "XXX", "XXX"));
-
- AddAndSetMember(&m_bool_type, std::make_unique<BooleanType>(this));
-
- Add(std::make_unique<BasicType>(this, "byte", "writeByte", "readByte", "writeByteArray",
- "createByteArray", "readByteArray"));
-
- Add(std::make_unique<CharType>(this));
-
- AddAndSetMember(&m_int_type,
- std::make_unique<BasicType>(this, "int", "writeInt", "readInt", "writeIntArray",
- "createIntArray", "readIntArray"));
-
- Add(std::make_unique<BasicType>(this, "long", "writeLong", "readLong", "writeLongArray",
- "createLongArray", "readLongArray"));
-
- Add(std::make_unique<BasicType>(this, "float", "writeFloat", "readFloat", "writeFloatArray",
- "createFloatArray", "readFloatArray"));
-
- Add(std::make_unique<BasicType>(this, "double", "writeDouble", "readDouble", "writeDoubleArray",
- "createDoubleArray", "readDoubleArray"));
-
- AddAndSetMember(&m_string_type, std::make_unique<class StringType>(this, "java.lang", "String"));
- Add(std::make_unique<class StringType>(this, ::android::aidl::kAidlReservedTypePackage,
- ::android::aidl::kUtf8InCppStringClass));
-
- Add(std::make_unique<Type>(this, "java.lang", "Object", ValidatableType::KIND_BUILT_IN, false));
-
- Add(std::make_unique<FileDescriptorType>(this));
-
- Add(std::make_unique<ParcelFileDescriptorType>(this));
-
- Add(std::make_unique<CharSequenceType>(this));
-
- Add(std::make_unique<MapType>(this));
-
- Add(std::make_unique<ListType>(this));
-
- AddAndSetMember(&m_text_utils_type,
- std::make_unique<Type>(this, "android.text", "TextUtils",
- ValidatableType::KIND_BUILT_IN, false));
-
- AddAndSetMember(&m_remote_exception_type, std::make_unique<class RemoteExceptionType>(this));
-
- AddAndSetMember(&m_runtime_exception_type, std::make_unique<class RuntimeExceptionType>(this));
-
- AddAndSetMember(&m_ibinder_type, std::make_unique<class IBinderType>(this));
-
- AddAndSetMember(&m_iinterface_type, std::make_unique<class IInterfaceType>(this));
-
- AddAndSetMember(&m_binder_native_type, std::make_unique<BinderType>(this));
-
- AddAndSetMember(&m_binder_proxy_type, std::make_unique<class BinderProxyType>(this));
-
- AddAndSetMember(&m_parcel_type, std::make_unique<class ParcelType>(this));
-
- AddAndSetMember(&m_parcelable_interface_type,
- std::make_unique<class ParcelableInterfaceType>(this));
-
- AddAndSetMember(&m_context_type, std::make_unique<Type>(this, "android.content", "Context",
- ValidatableType::KIND_BUILT_IN, false));
-
- AddAndSetMember(&m_classloader_type, std::make_unique<class ClassLoaderType>(this));
-}
-
-bool JavaTypeNamespace::AddParcelableType(const AidlParcelable& p,
- const std::string& filename) {
- return Add(
- std::make_unique<UserDataType>(this, p.GetPackage(), p.GetName(), false, true, filename));
-}
-
-bool JavaTypeNamespace::AddBinderType(const AidlInterface& b,
- const std::string& filename) {
- // for interfaces, add the stub, proxy, and interface types.
- auto stub = std::make_unique<Type>(this, b.GetPackage(), b.GetName() + ".Stub",
- ValidatableType::KIND_GENERATED, false, filename);
- auto proxy = std::make_unique<Type>(this, b.GetPackage(), b.GetName() + ".Stub.Proxy",
- ValidatableType::KIND_GENERATED, false, filename);
- auto defaultImpl = std::make_unique<Type>(this, b.GetPackage(), b.GetName() + ".Default",
- ValidatableType::KIND_GENERATED, false, filename);
- auto type = std::make_unique<InterfaceType>(this, b.GetPackage(), b.GetName(), false, filename,
- -1, stub.get(), proxy.get(), defaultImpl.get());
-
- bool success = true;
- success &= Add(std::move(type));
- success &= Add(std::move(stub));
- success &= Add(std::move(proxy));
- success &= Add(std::move(defaultImpl));
- return success;
-}
-
-bool JavaTypeNamespace::AddListType(const std::string& contained_type_name) {
- const Type* contained_type = FindTypeByCanonicalName(contained_type_name);
- if (!contained_type) {
- return false;
- }
- Add(std::make_unique<GenericListType>(this, contained_type));
- return true;
-}
-
-bool JavaTypeNamespace::AddMapType(const string& /*key_type_name*/,
- const string& /*value_type_name*/) {
- LOG(ERROR) << "Don't know how to create a Map<K,V> container.";
- return false;
-}
-
-} // namespace java
-} // namespace aidl
-} // namespace android
diff --git a/type_java.h b/type_java.h
deleted file mode 100644
index dc2c5fb..0000000
--- a/type_java.h
+++ /dev/null
@@ -1,336 +0,0 @@
-/*
- * Copyright (C) 2015, 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.
- */
-
-#pragma once
-
-#include <string>
-#include <vector>
-
-#include "ast_java.h"
-#include "type_namespace.h"
-
-namespace android {
-namespace aidl {
-namespace java {
-
-class JavaTypeNamespace;
-
-class Type : public ValidatableType {
- public:
- // WriteToParcel flags
- enum { PARCELABLE_WRITE_RETURN_VALUE = 0x0001 };
-
- // defaultValue is by default set to "null" because that is the default value
- // for most of the types like class and array. default values for built-in
- // types like int, double, boolean, etc. are explicitly set via BasicType
- Type(const JavaTypeNamespace* types, const std::string& name, int kind, bool canWriteToParcel);
- Type(const JavaTypeNamespace* types, const std::string& package, const std::string& name,
- int kind, bool canWriteToParcel, const std::string& declFile = "", int declLine = -1);
- virtual ~Type() = default;
-
- bool CanWriteToParcel() const override { return m_canWriteToParcel; }
-
- const ValidatableType* ArrayType() const override { return m_array_type.get(); }
- const ValidatableType* NullableType() const override { return nullptr; }
-
- virtual std::string JavaType() const { return m_javaType; }
- virtual std::string InstantiableName() const;
-
- // The namespace where this type is defined in
- const JavaTypeNamespace* GetTypeNamespace() const { return m_types; }
-
- protected:
- Expression* BuildWriteToParcelFlags(int flags) const;
-
- const JavaTypeNamespace* m_types;
-
- std::unique_ptr<Type> m_array_type;
-
- private:
- Type();
- Type(const Type&);
-
- std::string m_javaType;
- std::string m_declFile;
- bool m_canWriteToParcel;
-};
-
-class BasicArrayType : public Type {
- public:
- BasicArrayType(const JavaTypeNamespace* types, const std::string& name,
- const std::string& writeArrayParcel,
- const std::string& createArrayParcel,
- const std::string& readArrayParcel);
-
- const ValidatableType* NullableType() const override { return this; }
-
- private:
- std::string m_writeArrayParcel;
- std::string m_createArrayParcel;
- std::string m_readArrayParcel;
-};
-
-class BasicType : public Type {
- public:
- BasicType(const JavaTypeNamespace* types, const std::string& name,
- const std::string& marshallParcel, const std::string& unmarshallParcel,
- const std::string& writeArrayParcel, const std::string& createArrayParcel,
- const std::string& readArrayParcel);
-
- private:
- std::string m_marshallParcel;
- std::string m_unmarshallParcel;
-};
-
-class FileDescriptorArrayType : public Type {
- public:
- explicit FileDescriptorArrayType(const JavaTypeNamespace* types);
-
- const ValidatableType* NullableType() const override { return this; }
-};
-
-class FileDescriptorType : public Type {
- public:
- explicit FileDescriptorType(const JavaTypeNamespace* types);
-};
-
-class ParcelFileDescriptorArrayType : public Type {
- public:
- explicit ParcelFileDescriptorArrayType(const JavaTypeNamespace* types);
-
- const ValidatableType* NullableType() const override { return this; }
-};
-
-class ParcelFileDescriptorType : public Type {
- public:
- explicit ParcelFileDescriptorType(const JavaTypeNamespace* types);
-
- const ValidatableType* NullableType() const override { return this; }
-};
-
-class BooleanArrayType : public Type {
- public:
- explicit BooleanArrayType(const JavaTypeNamespace* types);
- const ValidatableType* NullableType() const override { return this; }
-};
-
-class BooleanType : public Type {
- public:
- explicit BooleanType(const JavaTypeNamespace* types);
-};
-
-class CharArrayType : public Type {
- public:
- explicit CharArrayType(const JavaTypeNamespace* types);
- const ValidatableType* NullableType() const override { return this; }
-};
-
-class CharType : public Type {
- public:
- explicit CharType(const JavaTypeNamespace* types);
-};
-
-class StringArrayType : public Type {
- public:
- explicit StringArrayType(const JavaTypeNamespace* types);
-
- const ValidatableType* NullableType() const override { return this; }
-};
-
-class StringType : public Type {
- public:
- StringType(const JavaTypeNamespace* types, const std::string& package,
- const std::string& class_name);
-
- std::string JavaType() const override { return "java.lang.String"; }
- const ValidatableType* NullableType() const override { return this; }
-};
-
-class CharSequenceType : public Type {
- public:
- explicit CharSequenceType(const JavaTypeNamespace* types);
-};
-
-class RemoteExceptionType : public Type {
- public:
- explicit RemoteExceptionType(const JavaTypeNamespace* types);
-};
-
-class RuntimeExceptionType : public Type {
- public:
- explicit RuntimeExceptionType(const JavaTypeNamespace* types);
-};
-
-class IBinderArrayType : public Type {
- public:
- explicit IBinderArrayType(const JavaTypeNamespace* types);
- const ValidatableType* NullableType() const override { return this; }
-};
-
-class IBinderType : public Type {
- public:
- explicit IBinderType(const JavaTypeNamespace* types);
- const ValidatableType* NullableType() const override { return this; }
-};
-
-class IInterfaceType : public Type {
- public:
- explicit IInterfaceType(const JavaTypeNamespace* types);
-};
-
-class BinderType : public Type {
- public:
- explicit BinderType(const JavaTypeNamespace* types);
-};
-
-class BinderProxyType : public Type {
- public:
- explicit BinderProxyType(const JavaTypeNamespace* types);
-};
-
-class ParcelType : public Type {
- public:
- explicit ParcelType(const JavaTypeNamespace* types);
- const ValidatableType* NullableType() const override { return this; }
-};
-
-class ParcelableInterfaceType : public Type {
- public:
- explicit ParcelableInterfaceType(const JavaTypeNamespace* types);
-};
-
-class MapType : public Type {
- public:
- explicit MapType(const JavaTypeNamespace* types);
- const ValidatableType* NullableType() const override { return this; }
-};
-
-class ListType : public Type {
- public:
- explicit ListType(const JavaTypeNamespace* types);
-
- std::string InstantiableName() const override;
- const ValidatableType* NullableType() const override { return this; }
-};
-
-class UserDataArrayType : public Type {
- public:
- UserDataArrayType(const JavaTypeNamespace* types, const std::string& package,
- const std::string& name, bool builtIn,
- bool canWriteToParcel, const std::string& declFile = "",
- int declLine = -1);
-
- const ValidatableType* NullableType() const override { return this; }
-};
-
-class UserDataType : public Type {
- public:
- UserDataType(const JavaTypeNamespace* types, const std::string& package,
- const std::string& name, bool builtIn, bool canWriteToParcel,
- const std::string& declFile = "", int declLine = -1);
-
- const ValidatableType* NullableType() const override { return this; }
-};
-
-class InterfaceType : public Type {
- public:
- InterfaceType(const JavaTypeNamespace* types, const std::string& package, const std::string& name,
- bool builtIn, const std::string& declFile, int declLine, const Type* stub,
- const Type* proxy, const Type* defaultImpl);
-
- const ValidatableType* NullableType() const override { return this; }
- const Type* GetStub() const { return stub_; }
- const Type* GetProxy() const { return proxy_; }
- const Type* GetDefaultImpl() const { return defaultImpl_; }
-
- private:
- const Type* stub_;
- const Type* proxy_;
- const Type* defaultImpl_;
-};
-
-class ClassLoaderType : public Type {
- public:
- explicit ClassLoaderType(const JavaTypeNamespace* types);
-};
-
-class GenericListType : public Type {
- public:
- GenericListType(const JavaTypeNamespace* types, const Type* arg);
-
- std::string InstantiableName() const override;
- std::string JavaType() const override {
- return "java.util.List<" + m_contained_type->JavaType() + ">";
- }
-
- const ValidatableType* NullableType() const override { return this; }
-
- private:
- const Type* m_contained_type;
-};
-
-class JavaTypeNamespace : public LanguageTypeNamespace<Type> {
- public:
- JavaTypeNamespace() = default;
- virtual ~JavaTypeNamespace() = default;
-
- void Init() override;
- bool AddParcelableType(const AidlParcelable& p,
- const std::string& filename) override;
- bool AddBinderType(const AidlInterface& b,
- const std::string& filename) override;
- bool AddListType(const std::string& contained_type_name) override;
- bool AddMapType(const std::string& key_type_name,
- const std::string& value_type_name) override;
-
- const Type* BoolType() const { return m_bool_type; }
- const Type* IntType() const { return m_int_type; }
- const Type* StringType() const { return m_string_type; }
- const Type* TextUtilsType() const { return m_text_utils_type; }
- const Type* RemoteExceptionType() const { return m_remote_exception_type; }
- const Type* RuntimeExceptionType() const { return m_runtime_exception_type; }
- const Type* IBinderType() const { return m_ibinder_type; }
- const Type* IInterfaceType() const { return m_iinterface_type; }
- const Type* BinderNativeType() const { return m_binder_native_type; }
- const Type* BinderProxyType() const { return m_binder_proxy_type; }
- const Type* ParcelType() const { return m_parcel_type; }
- const Type* ParcelableInterfaceType() const {
- return m_parcelable_interface_type;
- }
- const Type* ContextType() const { return m_context_type; }
- const Type* ClassLoaderType() const { return m_classloader_type; }
-
- private:
- const Type* m_bool_type{nullptr};
- const Type* m_int_type{nullptr};
- const Type* m_string_type{nullptr};
- const Type* m_text_utils_type{nullptr};
- const Type* m_remote_exception_type{nullptr};
- const Type* m_runtime_exception_type{nullptr};
- const Type* m_ibinder_type{nullptr};
- const Type* m_iinterface_type{nullptr};
- const Type* m_binder_native_type{nullptr};
- const Type* m_binder_proxy_type{nullptr};
- const Type* m_parcel_type{nullptr};
- const Type* m_parcelable_interface_type{nullptr};
- const Type* m_context_type{nullptr};
- const Type* m_classloader_type{nullptr};
-
- DISALLOW_COPY_AND_ASSIGN(JavaTypeNamespace);
-};
-} // namespace java
-} // namespace aidl
-} // namespace android
diff --git a/type_java_unittest.cpp b/type_java_unittest.cpp
deleted file mode 100644
index 0a5c94b..0000000
--- a/type_java_unittest.cpp
+++ /dev/null
@@ -1,67 +0,0 @@
-/*
- * Copyright (C) 2015, 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 <memory>
-
-#include <gtest/gtest.h>
-
-#include "aidl_language.h"
-#include "type_java.h"
-
-using std::unique_ptr;
-
-namespace android {
-namespace aidl {
-namespace java {
-
-class JavaTypeNamespaceTest : public ::testing::Test {
- protected:
- void SetUp() override {
- types_.Init();
- }
- JavaTypeNamespace types_;
-};
-
-TEST_F(JavaTypeNamespaceTest, HasSomeBasicTypes) {
- EXPECT_TRUE(types_.HasTypeByCanonicalName("void"));
- EXPECT_TRUE(types_.HasTypeByCanonicalName("int"));
- EXPECT_TRUE(types_.HasTypeByCanonicalName("java.lang.String"));
-}
-
-TEST_F(JavaTypeNamespaceTest, ContainerTypeCreation) {
- // We start with no knowledge of parcelables or lists of them.
- EXPECT_FALSE(types_.HasTypeByCanonicalName("Foo"));
- EXPECT_FALSE(types_.HasTypeByCanonicalName("java.util.List<a.goog.Foo>"));
- unique_ptr<AidlParcelable> parcelable(new AidlParcelable(
- AIDL_LOCATION_HERE, new AidlQualifiedName(AIDL_LOCATION_HERE, "Foo", ""), {"a", "goog"}, ""));
- // Add the parcelable type we care about.
- EXPECT_TRUE(types_.AddParcelableType(*parcelable.get(), __FILE__));
- // Now we can find the parcelable type, but not the List of them.
- EXPECT_TRUE(types_.HasTypeByCanonicalName("a.goog.Foo"));
- EXPECT_FALSE(types_.HasTypeByCanonicalName("java.util.List<a.goog.Foo>"));
- // But after we add the list explicitly...
- std::vector<std::unique_ptr<AidlTypeSpecifier>>* type_args =
- new std::vector<std::unique_ptr<AidlTypeSpecifier>>();
- type_args->emplace_back(new AidlTypeSpecifier(AIDL_LOCATION_HERE, "Foo", false, nullptr, ""));
- AidlTypeSpecifier container_type(AIDL_LOCATION_HERE, "List", false, type_args, "");
- EXPECT_TRUE(types_.MaybeAddContainerType(container_type));
- // This should work.
- EXPECT_TRUE(types_.HasTypeByCanonicalName("java.util.List<a.goog.Foo>"));
-}
-
-} // namespace java
-} // namespace aidl
-} // namespace android
diff --git a/type_namespace.cpp b/type_namespace.cpp
deleted file mode 100644
index e8e5a29..0000000
--- a/type_namespace.cpp
+++ /dev/null
@@ -1,164 +0,0 @@
-/*
- * Copyright (C) 2015, 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 "type_namespace.h"
-
-#include <algorithm>
-#include <string>
-#include <vector>
-
-#include "aidl_language.h"
-#include "logging.h"
-
-using android::base::StringPrintf;
-using std::string;
-using std::vector;
-
-namespace android {
-namespace aidl {
-
-// Since packages cannot contain '-' normally, we cannot be asked
-// to create a type that conflicts with these strings.
-const char kAidlReservedTypePackage[] = "aidl-internal";
-const char kUtf8InCppStringClass[] = "Utf8InCppString";
-
-// These *must* match the package and class names above.
-const char kUtf8InCppStringCanonicalName[] = "aidl-internal.Utf8InCppString";
-
-const char kStringCanonicalName[] = "java.lang.String";
-
-const char kUtf8InCppAnnotation[] = "@utfInCpp";
-
-namespace {
-
-bool is_java_keyword(const char* str) {
- static const std::vector<std::string> kJavaKeywords{
- "abstract", "assert", "boolean", "break", "byte",
- "case", "catch", "char", "class", "const",
- "continue", "default", "do", "double", "else",
- "enum", "extends", "final", "finally", "float",
- "for", "goto", "if", "implements", "import",
- "instanceof", "int", "interface", "long", "native",
- "new", "package", "private", "protected", "public",
- "return", "short", "static", "strictfp", "super",
- "switch", "synchronized", "this", "throw", "throws",
- "transient", "try", "void", "volatile", "while",
- "true", "false", "null",
- };
- return std::find(kJavaKeywords.begin(), kJavaKeywords.end(), str) !=
- kJavaKeywords.end();
-}
-
-} // namespace
-
-ValidatableType::ValidatableType(
- int kind, const string& package, const string& type_name,
- const string& decl_file, int decl_line)
- : kind_(kind),
- type_name_(type_name),
- canonical_name_((package.empty()) ? type_name
- : package + "." + type_name),
- origin_file_(decl_file),
- origin_line_(decl_line) {}
-
-string ValidatableType::HumanReadableKind() const {
- switch (Kind()) {
- case ValidatableType::KIND_BUILT_IN:
- return "a built in";
- case ValidatableType::KIND_PARCELABLE:
- return "a parcelable";
- case ValidatableType::KIND_INTERFACE:
- return "an interface";
- case ValidatableType::KIND_GENERATED:
- return "a generated";
- }
- return "unknown";
-}
-
-const ValidatableType* TypeNamespace::GetReturnType(const AidlTypeSpecifier& raw_type,
- const AidlDefinedType& context) const {
- string error_msg;
- const ValidatableType* return_type = GetValidatableType(raw_type, &error_msg, context);
- if (return_type == nullptr) {
- AIDL_ERROR(raw_type) << "Return type " << raw_type.ToString() << ": " << error_msg;
- return nullptr;
- }
-
- return return_type;
-}
-
-bool TypeNamespace::AddDefinedTypes(vector<AidlDefinedType*>& types, const string& filename) {
- bool success = true;
- for (const auto type : types) {
- const AidlInterface* interface = type->AsInterface();
- if (interface != nullptr) {
- success &= AddBinderType(*interface, filename);
- continue;
- }
-
- const AidlParcelable* parcelable = type->AsParcelable();
- if (parcelable != nullptr) {
- success &= AddParcelableType(*parcelable, filename);
- continue;
- }
-
- CHECK(false) << "aidl internal error: unrecognized type";
- }
- return success;
-}
-
-const ValidatableType* TypeNamespace::GetArgType(const AidlArgument& a, int arg_index,
- const AidlDefinedType& context) const {
- string error_prefix =
- StringPrintf("parameter %s (argument %d): ", a.GetName().c_str(), arg_index);
-
- // check the arg type
- string error_msg;
- const ValidatableType* t = GetValidatableType(a.GetType(), &error_msg, context);
- if (t == nullptr) {
- AIDL_ERROR(a) << error_prefix << error_msg;
- return nullptr;
- }
-
- const bool can_be_out = typenames_.CanBeOutParameter(a.GetType());
- if (!a.DirectionWasSpecified() && can_be_out) {
- AIDL_ERROR(a) << error_prefix << "'" << a.GetType().ToString()
- << "' can be an out type, so you must declare it as in, out, or inout.";
- return nullptr;
- }
-
- if (a.GetDirection() != AidlArgument::IN_DIR && !can_be_out) {
- AIDL_ERROR(a) << error_prefix << "'" << a.ToString() << "' can only be an in parameter.";
- return nullptr;
- }
-
- // check that the name doesn't match a keyword
- if (is_java_keyword(a.GetName().c_str())) {
- AIDL_ERROR(a) << error_prefix << "Argument name is a Java or aidl keyword";
- return nullptr;
- }
-
- // Reserve a namespace for internal use
- if (a.GetName().substr(0, 5) == "_aidl") {
- AIDL_ERROR(a) << error_prefix << "Argument name cannot begin with '_aidl'";
- return nullptr;
- }
-
- return t;
-}
-
-} // namespace aidl
-} // namespace android
diff --git a/type_namespace.h b/type_namespace.h
deleted file mode 100644
index a7952fb..0000000
--- a/type_namespace.h
+++ /dev/null
@@ -1,450 +0,0 @@
-/*
- * Copyright (C) 2015, 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.
- */
-
-#pragma once
-
-#include <memory>
-#include <string>
-
-#include <android-base/macros.h>
-#include <android-base/stringprintf.h>
-#include <android-base/strings.h>
-
-#include "aidl_language.h"
-#include "logging.h"
-
-namespace android {
-namespace aidl {
-
-// Special reserved type names.
-extern const char kAidlReservedTypePackage[];
-extern const char kUtf8InCppStringClass[]; // UTF16 wire format, UTF8 in C++
-
-// Helpful aliases defined to be <kAidlReservedTypePackage>.<class name>
-extern const char kUtf8InCppStringCanonicalName[];
-
-// We sometimes special case this class.
-extern const char kStringCanonicalName[];
-
-// Note that these aren't the strings recognized by the parser, we just keep
-// here for the sake of logging a common string constant.
-extern const char kUtf8InCppAnnotation[];
-
-class ValidatableType {
- public:
- enum {
- KIND_BUILT_IN,
- KIND_PARCELABLE,
- KIND_INTERFACE,
- KIND_GENERATED,
- };
-
- ValidatableType(int kind,
- const std::string& package, const std::string& type_name,
- const std::string& decl_file, int decl_line);
- virtual ~ValidatableType() = default;
-
- virtual bool CanBeArray() const { return ArrayType() != nullptr; }
- virtual bool CanWriteToParcel() const = 0;
-
- virtual const ValidatableType* ArrayType() const = 0;
- virtual const ValidatableType* NullableType() const = 0;
-
- // ShortName() is the class name without a package.
- std::string ShortName() const { return type_name_; }
- // CanonicalName() returns the canonical AIDL type, with packages.
- std::string CanonicalName() const { return canonical_name_; }
-
- int Kind() const { return kind_; }
- std::string HumanReadableKind() const;
- std::string DeclFile() const { return origin_file_; }
- int DeclLine() const { return origin_line_; }
-
- private:
- const int kind_;
- const std::string type_name_;
- const std::string canonical_name_;
- const std::string origin_file_;
- const int origin_line_;
-
- DISALLOW_COPY_AND_ASSIGN(ValidatableType);
-};
-
-class TypeNamespace {
- public:
- // Load the TypeNamespace with built in types. Don't do work in the
- // constructor because many of the useful methods are virtual.
- virtual void Init() = 0;
-
- bool AddDefinedTypes(vector<AidlDefinedType*>& types, const string& filename);
-
- // Load this TypeNamespace with user defined types.
- virtual bool AddParcelableType(const AidlParcelable& p,
- const std::string& filename) = 0;
-
- virtual bool AddBinderType(const AidlInterface& b,
- const std::string& filename) = 0;
- // Add a container type to this namespace. Returns false only
- // on error. Silently discards requests to add non-container types.
- virtual bool MaybeAddContainerType(const AidlTypeSpecifier& aidl_type) = 0;
-
- // Returns true iff this has a type for |import|.
- virtual bool HasImportType(const std::string& import) const = 0;
-
- // Returns a pointer to a type corresponding to |raw_type| or nullptr
- // if this is an invalid return type.
- virtual const ValidatableType* GetReturnType(const AidlTypeSpecifier& raw_type,
- const AidlDefinedType& context) const;
-
- // Returns a pointer to a type corresponding to |a| or nullptr if |a|
- // has an invalid argument type.
- virtual const ValidatableType* GetArgType(const AidlArgument& a, int arg_index,
- const AidlDefinedType& context) const;
-
- // Returns a pointer to a type corresponding to |defined_type|.
- virtual const ValidatableType* GetDefinedType(const AidlDefinedType& defined_type) const = 0;
-
- AidlTypenames typenames_;
-
- protected:
- TypeNamespace() = default;
- virtual ~TypeNamespace() = default;
-
- virtual const ValidatableType* GetValidatableType(const AidlTypeSpecifier& type,
- std::string* error_msg,
- const AidlDefinedType& context) const = 0;
-
- private:
- DISALLOW_COPY_AND_ASSIGN(TypeNamespace);
-};
-
-template<typename T>
-class LanguageTypeNamespace : public TypeNamespace {
- public:
- LanguageTypeNamespace() = default;
- virtual ~LanguageTypeNamespace() = default;
-
- // Get a pointer to an existing type. Searches first by fully-qualified
- // name, and then class name (dropping package qualifiers).
- const T* Find(const AidlTypeSpecifier& aidl_type) const;
-
- // Find a type by its |name|. If |name| refers to a container type (e.g.
- // List<String>) you must turn it into a canonical name first (e.g.
- // java.util.List<java.lang.String>).
- const T* FindTypeByCanonicalName(const std::string& name) const;
- bool HasTypeByCanonicalName(const std::string& type_name) const {
- return FindTypeByCanonicalName(type_name) != nullptr;
- }
- bool HasImportType(const std::string& import) const override {
- return HasTypeByCanonicalName(import);
- }
- const ValidatableType* GetDefinedType(const AidlDefinedType& defined_type) const override {
- return FindTypeByCanonicalName(defined_type.GetCanonicalName());
- }
-
- bool MaybeAddContainerType(const AidlTypeSpecifier& aidl_type) override;
- // We dynamically create container types as we discover them in the parse
- // tree. Returns false if the contained types cannot be canonicalized.
- virtual bool AddListType(const std::string& contained_type_name) = 0;
- virtual bool AddMapType(const std::string& key_type_name,
- const std::string& value_type_name) = 0;
-
- protected:
- bool Add(std::unique_ptr<const T> type);
- void AddAndSetMember(const T** member, std::unique_ptr<const T> type) {
- const T* ptr_value = type.get();
- CHECK(Add(std::move(type)));
- *member = ptr_value;
- }
-
- private:
- // Returns true iff the name can be canonicalized to a container type.
- virtual bool CanonicalizeContainerType(const AidlTypeSpecifier& aidl_type,
- std::vector<std::string>* container_class,
- std::vector<std::string>* contained_type_names) const;
-
- // Returns true if this is a container type, rather than a normal type.
- bool IsContainerType(const std::string& type_name) const;
-
- const ValidatableType* GetValidatableType(const AidlTypeSpecifier& type, std::string* error_msg,
- const AidlDefinedType& context) const override;
-
- std::vector<std::unique_ptr<const T>> types_;
-
- DISALLOW_COPY_AND_ASSIGN(LanguageTypeNamespace);
-}; // class LanguageTypeNamespace
-
-template <typename T>
-bool LanguageTypeNamespace<T>::Add(std::unique_ptr<const T> type) {
- const T* existing = FindTypeByCanonicalName(type->CanonicalName());
- if (!existing) {
- types_.push_back(std::move(type));
- return true;
- }
-
- if (existing->Kind() == ValidatableType::KIND_BUILT_IN) {
- LOG(ERROR) << type->DeclFile() << ":" << type->DeclLine()
- << " attempt to redefine built in class "
- << type->CanonicalName();
- return false;
- }
-
- if (type->Kind() != existing->Kind()) {
- LOG(ERROR) << type->DeclFile() << ":" << type->DeclLine()
- << " attempt to redefine " << type->CanonicalName()
- << " as " << type->HumanReadableKind();
- LOG(ERROR) << existing->DeclFile() << ":" << existing->DeclLine()
- << " previously defined here as "
- << existing->HumanReadableKind();
- return false;
- }
-
- return true;
-}
-
-template <typename T>
-const T* LanguageTypeNamespace<T>::Find(const AidlTypeSpecifier& aidl_type) const {
- using std::string;
- using std::vector;
- using android::base::Join;
- using android::base::Trim;
-
- string name = Trim(aidl_type.IsArray() ? aidl_type.GetName() : aidl_type.ToString());
- if (IsContainerType(name)) {
- vector<string> container_class;
- vector<string> contained_type_names;
- if (!CanonicalizeContainerType(aidl_type, &container_class,
- &contained_type_names)) {
- return nullptr;
- }
- name = Join(container_class, '.') +
- "<" + Join(contained_type_names, ',') + ">";
- }
- // Here, we know that we have the canonical name for this container.
- return FindTypeByCanonicalName(name);
-}
-
-template<typename T>
-const T* LanguageTypeNamespace<T>::FindTypeByCanonicalName(
- const std::string& raw_name) const {
- using android::base::Trim;
-
- std::string name = Trim(raw_name);
- const T* ret = nullptr;
- for (const auto& type : types_) {
- // Always prefer a exact match if possible.
- // This works for primitives and class names qualified with a package.
- if (type->CanonicalName() == name) {
- ret = type.get();
- break;
- }
- // We allow authors to drop packages when refering to a class name.
- if (type->ShortName() == name) {
- ret = type.get();
- }
- }
-
- return ret;
-}
-
-template <typename T>
-bool LanguageTypeNamespace<T>::MaybeAddContainerType(const AidlTypeSpecifier& aidl_type) {
- using android::base::Join;
-
- const std::string& type_name = aidl_type.ToString();
- if (!IsContainerType(type_name)) {
- return true;
- }
-
- std::vector<std::string> container_class;
- std::vector<std::string> contained_type_names;
- if (!CanonicalizeContainerType(aidl_type, &container_class,
- &contained_type_names)) {
- return false;
- }
-
- const std::string canonical_name = Join(container_class, ".") +
- "<" + Join(contained_type_names, ",") + ">";
- if (HasTypeByCanonicalName(canonical_name)) {
- return true;
- }
-
-
- // We only support two types right now and this type is one of them.
- switch (contained_type_names.size()) {
- case 1:
- return AddListType(contained_type_names[0]);
- case 2:
- return AddMapType(contained_type_names[0], contained_type_names[1]);
- default:
- break; // Should never get here, will FATAL below.
- }
-
- LOG(FATAL) << "aidl internal error";
- return false;
-}
-
-template<typename T>
-bool LanguageTypeNamespace<T>::IsContainerType(
- const std::string& type_name) const {
- const size_t opening_brace = type_name.find('<');
- const size_t closing_brace = type_name.find('>');
- if (opening_brace != std::string::npos ||
- closing_brace != std::string::npos) {
- return true; // Neither < nor > appear in normal AIDL types.
- }
- return false;
-}
-
-template <typename T>
-bool LanguageTypeNamespace<T>::CanonicalizeContainerType(
- const AidlTypeSpecifier& aidl_type, std::vector<std::string>* container_class,
- std::vector<std::string>* contained_type_names) const {
- std::string container = aidl_type.GetName();
- std::vector<std::string> args;
- for (auto& type_arg : aidl_type.GetTypeParameters()) {
- if (type_arg->IsGeneric()) {
- // nesting is not allowed yet.
- LOG(ERROR) << "Nested template type '" << aidl_type.ToString() << "'";
- }
-
- std::string type_name = type_arg->ToString();
- // Here, we are relying on FindTypeByCanonicalName to do its best when
- // given a non-canonical name for non-compound type (i.e. not another
- // container).
- const T* arg_type = FindTypeByCanonicalName(type_name);
- if (!arg_type) {
- return false;
- }
-
- // Now get the canonical names for these contained types, remapping them if
- // necessary.
- type_name = arg_type->CanonicalName();
- if (aidl_type.IsUtf8InCpp() && type_name == "java.lang.String") {
- type_name = kUtf8InCppStringCanonicalName;
- }
- args.emplace_back(type_name);
- }
-
- // Map the container name to its canonical form for supported containers.
- if ((container == "List" || container == "java.util.List") &&
- args.size() == 1) {
- *container_class = {"java", "util", "List"};
- *contained_type_names = args;
- return true;
- }
- if ((container == "Map" || container == "java.util.Map") &&
- args.size() == 2) {
- *container_class = {"java", "util", "Map"};
- *contained_type_names = args;
- return true;
- }
-
- LOG(ERROR) << "Unknown find container with name " << container << " and " << args.size()
- << " contained types.";
- return false;
-}
-
-template <typename T>
-const ValidatableType* LanguageTypeNamespace<T>::GetValidatableType(
- const AidlTypeSpecifier& aidl_type, std::string* error_msg,
- const AidlDefinedType& context) const {
- using android::base::StringPrintf;
-
- const ValidatableType* type = Find(aidl_type);
- if (type == nullptr) {
- *error_msg = "unknown type";
- return nullptr;
- }
-
- if (aidl_type.GetName() == "void") {
- if (aidl_type.IsArray()) {
- *error_msg = "void type cannot be an array";
- return nullptr;
- }
- if (aidl_type.IsNullable() || aidl_type.IsUtf8InCpp()) {
- *error_msg = "void type cannot be annotated";
- return nullptr;
- }
- // We have no more special handling for void.
- return type;
- }
-
- bool utf8InCpp = aidl_type.IsUtf8InCpp();
-
- // Strings inside containers get remapped to appropriate utf8 versions when
- // we convert the container name to its canonical form and the look up the
- // type. However, for non-compound types (i.e. those not in a container) we
- // must patch them up here.
- if (IsContainerType(type->CanonicalName())) {
- utf8InCpp = false;
- } else if (aidl_type.GetName() == "String" ||
- aidl_type.GetName() == "java.lang.String") {
- utf8InCpp = utf8InCpp || context.IsUtf8InCpp();
- } else if (utf8InCpp) {
- *error_msg = StringPrintf("type '%s' may not be annotated as %s.", aidl_type.GetName().c_str(),
- kUtf8InCppAnnotation);
- return nullptr;
- }
-
- if (utf8InCpp) {
- type = FindTypeByCanonicalName(kUtf8InCppStringCanonicalName);
- }
-
- // One of our UTF8 transforms made type null
- if (type == nullptr) {
- *error_msg = StringPrintf("%s is unsupported when generating code for this language.",
- kUtf8InCppAnnotation);
- return nullptr;
- }
-
- if (!type->CanWriteToParcel()) {
- *error_msg = "type cannot be marshalled";
- return nullptr;
- }
-
- if (aidl_type.IsArray()) {
- type = type->ArrayType();
- if (!type) {
- *error_msg = StringPrintf("type '%s' cannot be an array",
- aidl_type.GetName().c_str());
- return nullptr;
- }
- }
-
- if (context.IsNullable()) {
- const ValidatableType* nullableType = type->NullableType();
-
- if (nullableType) {
- return nullableType;
- }
- }
-
- if (aidl_type.IsNullable()) {
- type = type->NullableType();
- if (!type) {
- *error_msg = StringPrintf("type '%s%s' cannot be marked as possibly null",
- aidl_type.GetName().c_str(),
- (aidl_type.IsArray()) ? "[]" : "");
- return nullptr;
- }
- }
-
- return type;
-}
-
-} // namespace aidl
-} // namespace android
