zircon/system/utest/fidl-compiler/test_library.h - fuchsia - Git at Google

 // Copyright 2018 The Fuchsia Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.

 #ifndef ZIRCON_SYSTEM_UTEST_FIDL_COMPILER_TEST_LIBRARY_H_
 #define ZIRCON_SYSTEM_UTEST_FIDL_COMPILER_TEST_LIBRARY_H_

 #include <fidl/flat_ast.h>
 #include <fidl/json_generator.h>
 #include <fidl/lexer.h>
 #include <fidl/linter.h>
 #include <fidl/ordinals.h>
 #include <fidl/parser.h>
 #include <fidl/source_file.h>
 #include <fidl/tables_generator.h>

 static std::unique_ptr<fidl::SourceFile> MakeSourceFile(const std::string& filename,
                                                         const std::string& raw_source_code) {
   std::string source_code(raw_source_code);
   // NUL terminate the string.
   source_code.resize(source_code.size() + 1);
   return std::make_unique<fidl::SourceFile>(filename, source_code);
 }

 class SharedAmongstLibraries {
  public:
   SharedAmongstLibraries() : typespace(fidl::flat::Typespace::RootTypes(&reporter)) {}

   fidl::Reporter reporter;
   fidl::flat::Typespace typespace;
   fidl::flat::Libraries all_libraries;
   std::vector<std::unique_ptr<fidl::SourceFile>> all_sources_of_all_libraries;
 };

 namespace {

 // See ordinals_test.cc
 fidl::raw::Ordinal64 GetGeneratedOrdinal64ForTesting(
     const std::vector<std::string_view>& library_name, const std::string_view& protocol_name,
     const std::string_view& selector_name, const fidl::raw::SourceElement& source_element) {
   static std::map<std::string, uint64_t> special_selectors = {
       {"ThisOneHashesToZero", 0},
       {"ClashOne", 456789},
       {"ClashOneReplacement", 987654},
       {"ClashTwo", 456789},
   };
   if (library_name.size() == 1 && library_name[0] == "methodhasher" &&
       (protocol_name == "Special" || protocol_name == "SpecialComposed")) {
     auto it = special_selectors.find(std::string(selector_name));
     assert(it != special_selectors.end() && "only special selectors allowed");
     return fidl::raw::Ordinal64(source_element, it->second);
   }
   return fidl::ordinals::GetGeneratedOrdinal64(library_name, protocol_name, selector_name,
                                                source_element);
 }
 };  // namespace

 class TestLibrary final {
  public:
   explicit TestLibrary() : TestLibrary(&owned_shared_) {}

   explicit TestLibrary(SharedAmongstLibraries* shared,
                        fidl::ExperimentalFlags experimental_flags = fidl::ExperimentalFlags())
       : reporter_(&shared->reporter),
         experimental_flags_(experimental_flags),
         typespace_(&shared->typespace),
         all_libraries_(&shared->all_libraries),
         all_sources_of_all_libraries_(&shared->all_sources_of_all_libraries),
         library_(std::make_unique<fidl::flat::Library>(all_libraries_, reporter_, typespace_,
                                                        GetGeneratedOrdinal64ForTesting,
                                                        experimental_flags_)) {}

   explicit TestLibrary(const std::string& raw_source_code,
                        fidl::ExperimentalFlags experimental_flags = fidl::ExperimentalFlags())
       : TestLibrary("example.fidl", raw_source_code, experimental_flags) {}

   TestLibrary(const std::string& filename, const std::string& raw_source_code,
               fidl::ExperimentalFlags experimental_flags = fidl::ExperimentalFlags())
       : TestLibrary(filename, raw_source_code, &owned_shared_, experimental_flags) {}

   TestLibrary(const std::string& filename, const std::string& raw_source_code,
               SharedAmongstLibraries* shared,
               fidl::ExperimentalFlags experimental_flags = fidl::ExperimentalFlags())
       : TestLibrary(shared, experimental_flags) {
     AddSource(filename, raw_source_code);
   }

   void AddSource(const std::string& filename, const std::string& raw_source_code) {
     auto source_file = MakeSourceFile(filename, raw_source_code);
     all_sources_.push_back(source_file.get());
     all_sources_of_all_libraries_->push_back(std::move(source_file));
   }

   bool AddDependentLibrary(TestLibrary dependent_library) {
     return all_libraries_->Insert(std::move(dependent_library.library_));
   }

   void AddAttributeSchema(const std::string& name, fidl::flat::AttributeSchema schema) {
     all_libraries_->AddAttributeSchema(name, std::move(schema));
   }

   // TODO(pascallouis): remove, this does not use a library.
   bool Parse(std::unique_ptr<fidl::raw::File>* out_ast_ptr) {
     assert(all_sources_.size() == 1 && "parse can only be used with one source");
     auto source_file = all_sources_.at(0);
     fidl::Lexer lexer(*source_file, reporter_);
     fidl::Parser parser(&lexer, reporter_, experimental_flags_);
     out_ast_ptr->reset(parser.Parse().release());
     return parser.Success();
   }

   bool Compile() {
     for (auto source_file : all_sources_) {
       fidl::Lexer lexer(*source_file, reporter_);
       fidl::Parser parser(&lexer, reporter_, experimental_flags_);
       auto ast = parser.Parse();
       if (!parser.Success())
         return false;
       if (!library_->ConsumeFile(std::move(ast)))
         return false;
     }
     return library_->Compile();
   }

   // TODO(pascallouis): remove, this does not use a library.
   bool Lint(fidl::Findings* findings, const std::set<std::string>& included_check_ids = {},
             const std::set<std::string>& excluded_check_ids = {}, bool exclude_by_default = false,
             std::set<std::string>* excluded_checks_not_found = nullptr) {
     assert(all_sources_.size() == 1 && "lint can only be used with one source");
     auto source_file = all_sources_.at(0);
     fidl::Lexer lexer(*source_file, reporter_);
     fidl::Parser parser(&lexer, reporter_, experimental_flags_);
     auto ast = parser.Parse();
     if (!parser.Success()) {
       std::string_view beginning(source_file->data().data(), 0);
       fidl::SourceSpan span(beginning, *source_file);
       const auto& error = reporter_->errors().at(0);
       size_t squiggle_size = error->span ? error->span.value().data().size() : 0;
       auto error_msg =
           fidl::reporter::Format("error", error->span, error->msg, false, squiggle_size);
       findings->emplace_back(span, "parser-error", error_msg + "\n");
       return false;
     }
     fidl::linter::Linter linter;
     if (!included_check_ids.empty()) {
       linter.set_included_checks(included_check_ids);
     }
     if (!excluded_check_ids.empty()) {
       linter.set_excluded_checks(excluded_check_ids);
     }
     linter.set_exclude_by_default(exclude_by_default);
     return linter.Lint(ast, findings, excluded_checks_not_found);
   }

   bool Lint() {
     fidl::Findings findings;
     bool passed = Lint(&findings);
     lints_ = fidl::utils::FormatFindings(findings, false);
     return passed;
   }

   std::string GenerateJSON() {
     auto json_generator = fidl::JSONGenerator(library_.get());
     auto out = json_generator.Produce();
     return out.str();
   }

   std::string GenerateTables() {
     auto tables_generator = fidl::TablesGenerator(library_.get());
     auto out = tables_generator.Produce();
     return out.str();
   }

   const fidl::flat::Bits* LookupBits(const std::string& name) {
     for (const auto& bits_decl : library_->bits_declarations_) {
       if (bits_decl->GetName() == name) {
         return bits_decl.get();
       }
     }
     return nullptr;
   }

   const fidl::flat::Const* LookupConstant(const std::string& name) {
     for (const auto& const_decl : library_->const_declarations_) {
       if (const_decl->GetName() == name) {
         return const_decl.get();
       }
     }
     return nullptr;
   }

   const fidl::flat::Enum* LookupEnum(const std::string& name) {
     for (const auto& enum_decl : library_->enum_declarations_) {
       if (enum_decl->GetName() == name) {
         return enum_decl.get();
       }
     }
     return nullptr;
   }

   const fidl::flat::Resource* LookupResource(const std::string& name) {
     for (const auto& resource_decl : library_->resource_declarations_) {
       if (resource_decl->GetName() == name) {
         return resource_decl.get();
       }
     }
     return nullptr;
   }

   const fidl::flat::Service* LookupService(const std::string& name) {
     for (const auto& service_decl : library_->service_declarations_) {
       if (service_decl->GetName() == name) {
         return service_decl.get();
       }
     }
     return nullptr;
   }

   const fidl::flat::Struct* LookupStruct(const std::string& name) {
     for (const auto& struct_decl : library_->struct_declarations_) {
       if (struct_decl->GetName() == name) {
         return struct_decl.get();
       }
     }
     return nullptr;
   }

   const fidl::flat::Table* LookupTable(const std::string& name) {
     for (const auto& table_decl : library_->table_declarations_) {
       if (table_decl->GetName() == name) {
         return table_decl.get();
       }
     }
     return nullptr;
   }

   const fidl::flat::TypeAlias* LookupTypeAlias(const std::string& name) {
     for (const auto& type_alias_decl : library_->type_alias_declarations_) {
       if (type_alias_decl->GetName() == name) {
         return type_alias_decl.get();
       }
     }
     return nullptr;
   }

   const fidl::flat::Union* LookupUnion(const std::string& name) {
     for (const auto& union_decl : library_->union_declarations_) {
       if (union_decl->GetName() == name) {
         return union_decl.get();
       }
     }
     return nullptr;
   }

   const fidl::flat::Protocol* LookupProtocol(const std::string& name) {
     for (const auto& protocol_decl : library_->protocol_declarations_) {
       if (protocol_decl->GetName() == name) {
         return protocol_decl.get();
       }
     }
     return nullptr;
   }

   void set_warnings_as_errors(bool value) { reporter_->set_warnings_as_errors(value); }

   const fidl::flat::Library* library() const { return library_.get(); }

   const fidl::SourceFile& source_file() const {
     assert(all_sources_.size() == 1 && "convenience method only possible with single source");
     return *all_sources_.at(0);
   }

   fidl::SourceSpan source_span(size_t start, size_t size) const {
     assert(all_sources_.size() == 1 && "convenience method only possible with single source");
     std::string_view data = all_sources_.at(0)->data();
     data.remove_prefix(start);
     data.remove_suffix(data.size() - size);
     return fidl::SourceSpan(data, *all_sources_.at(0));
   }

   std::vector<fidl::Diagnostic*> diagnostics() const { return reporter_->diagnostics(); }

   const std::vector<std::unique_ptr<fidl::Diagnostic>>& errors() const {
     return reporter_->errors();
   }

   const std::vector<std::unique_ptr<fidl::Diagnostic>>& warnings() const {
     return reporter_->warnings();
   }

   const std::vector<std::string>& lints() const { return lints_; }

   const std::vector<fidl::flat::Decl*> declaration_order() const {
     return library_->declaration_order_;
   }

  protected:
   SharedAmongstLibraries owned_shared_;
   fidl::Reporter* reporter_;
   std::vector<std::string> lints_;
   fidl::ExperimentalFlags experimental_flags_;
   fidl::flat::Typespace* typespace_;
   fidl::flat::Libraries* all_libraries_;
   std::vector<std::unique_ptr<fidl::SourceFile>>* all_sources_of_all_libraries_;
   std::vector<fidl::SourceFile*> all_sources_;
   std::unique_ptr<fidl::flat::Library> library_;
 };

 #endif  // ZIRCON_SYSTEM_UTEST_FIDL_COMPILER_TEST_LIBRARY_H_
	// Copyright 2018 The Fuchsia Authors. All rights reserved.
	// Use of this source code is governed by a BSD-style license that can be
	// found in the LICENSE file.

	#ifndef ZIRCON_SYSTEM_UTEST_FIDL_COMPILER_TEST_LIBRARY_H_
	#define ZIRCON_SYSTEM_UTEST_FIDL_COMPILER_TEST_LIBRARY_H_

	#include <fidl/flat_ast.h>
	#include <fidl/json_generator.h>
	#include <fidl/lexer.h>
	#include <fidl/linter.h>
	#include <fidl/ordinals.h>
	#include <fidl/parser.h>
	#include <fidl/source_file.h>
	#include <fidl/tables_generator.h>

	static std::unique_ptr<fidl::SourceFile> MakeSourceFile(const std::string& filename,
	const std::string& raw_source_code) {
	std::string source_code(raw_source_code);
	// NUL terminate the string.
	source_code.resize(source_code.size() + 1);
	return std::make_unique<fidl::SourceFile>(filename, source_code);
	}

	class SharedAmongstLibraries {
	public:
	SharedAmongstLibraries() : typespace(fidl::flat::Typespace::RootTypes(&reporter)) {}

	fidl::Reporter reporter;
	fidl::flat::Typespace typespace;
	fidl::flat::Libraries all_libraries;
	std::vector<std::unique_ptr<fidl::SourceFile>> all_sources_of_all_libraries;
	};

	namespace {

	// See ordinals_test.cc
	fidl::raw::Ordinal64 GetGeneratedOrdinal64ForTesting(
	const std::vector<std::string_view>& library_name, const std::string_view& protocol_name,
	const std::string_view& selector_name, const fidl::raw::SourceElement& source_element) {
	static std::map<std::string, uint64_t> special_selectors = {
	{"ThisOneHashesToZero", 0},
	{"ClashOne", 456789},
	{"ClashOneReplacement", 987654},
	{"ClashTwo", 456789},
	};
	if (library_name.size() == 1 && library_name[0] == "methodhasher" &&
	(protocol_name == "Special" \|\| protocol_name == "SpecialComposed")) {
	auto it = special_selectors.find(std::string(selector_name));
	assert(it != special_selectors.end() && "only special selectors allowed");
	return fidl::raw::Ordinal64(source_element, it->second);
	}
	return fidl::ordinals::GetGeneratedOrdinal64(library_name, protocol_name, selector_name,
	source_element);
	}
	}; // namespace

	class TestLibrary final {
	public:
	explicit TestLibrary() : TestLibrary(&owned_shared_) {}

	explicit TestLibrary(SharedAmongstLibraries* shared,
	fidl::ExperimentalFlags experimental_flags = fidl::ExperimentalFlags())
	: reporter_(&shared->reporter),
	experimental_flags_(experimental_flags),
	typespace_(&shared->typespace),
	all_libraries_(&shared->all_libraries),
	all_sources_of_all_libraries_(&shared->all_sources_of_all_libraries),
	library_(std::make_unique<fidl::flat::Library>(all_libraries_, reporter_, typespace_,
	GetGeneratedOrdinal64ForTesting,
	experimental_flags_)) {}

	explicit TestLibrary(const std::string& raw_source_code,
	fidl::ExperimentalFlags experimental_flags = fidl::ExperimentalFlags())
	: TestLibrary("example.fidl", raw_source_code, experimental_flags) {}

	TestLibrary(const std::string& filename, const std::string& raw_source_code,
	fidl::ExperimentalFlags experimental_flags = fidl::ExperimentalFlags())
	: TestLibrary(filename, raw_source_code, &owned_shared_, experimental_flags) {}

	TestLibrary(const std::string& filename, const std::string& raw_source_code,
	SharedAmongstLibraries* shared,
	fidl::ExperimentalFlags experimental_flags = fidl::ExperimentalFlags())
	: TestLibrary(shared, experimental_flags) {
	AddSource(filename, raw_source_code);
	}

	void AddSource(const std::string& filename, const std::string& raw_source_code) {
	auto source_file = MakeSourceFile(filename, raw_source_code);
	all_sources_.push_back(source_file.get());
	all_sources_of_all_libraries_->push_back(std::move(source_file));
	}

	bool AddDependentLibrary(TestLibrary dependent_library) {
	return all_libraries_->Insert(std::move(dependent_library.library_));
	}

	void AddAttributeSchema(const std::string& name, fidl::flat::AttributeSchema schema) {
	all_libraries_->AddAttributeSchema(name, std::move(schema));
	}

	// TODO(pascallouis): remove, this does not use a library.
	bool Parse(std::unique_ptr<fidl::raw::File>* out_ast_ptr) {
	assert(all_sources_.size() == 1 && "parse can only be used with one source");
	auto source_file = all_sources_.at(0);
	fidl::Lexer lexer(*source_file, reporter_);
	fidl::Parser parser(&lexer, reporter_, experimental_flags_);
	out_ast_ptr->reset(parser.Parse().release());
	return parser.Success();
	}

	bool Compile() {
	for (auto source_file : all_sources_) {
	fidl::Lexer lexer(*source_file, reporter_);
	fidl::Parser parser(&lexer, reporter_, experimental_flags_);
	auto ast = parser.Parse();
	if (!parser.Success())
	return false;
	if (!library_->ConsumeFile(std::move(ast)))
	return false;
	}
	return library_->Compile();
	}

	// TODO(pascallouis): remove, this does not use a library.
	bool Lint(fidl::Findings* findings, const std::set<std::string>& included_check_ids = {},
	const std::set<std::string>& excluded_check_ids = {}, bool exclude_by_default = false,
	std::set<std::string>* excluded_checks_not_found = nullptr) {
	assert(all_sources_.size() == 1 && "lint can only be used with one source");
	auto source_file = all_sources_.at(0);
	fidl::Lexer lexer(*source_file, reporter_);
	fidl::Parser parser(&lexer, reporter_, experimental_flags_);
	auto ast = parser.Parse();
	if (!parser.Success()) {
	std::string_view beginning(source_file->data().data(), 0);
	fidl::SourceSpan span(beginning, *source_file);
	const auto& error = reporter_->errors().at(0);
	size_t squiggle_size = error->span ? error->span.value().data().size() : 0;
	auto error_msg =
	fidl::reporter::Format("error", error->span, error->msg, false, squiggle_size);
	findings->emplace_back(span, "parser-error", error_msg + "\n");
	return false;
	}
	fidl::linter::Linter linter;
	if (!included_check_ids.empty()) {
	linter.set_included_checks(included_check_ids);
	}
	if (!excluded_check_ids.empty()) {
	linter.set_excluded_checks(excluded_check_ids);
	}
	linter.set_exclude_by_default(exclude_by_default);
	return linter.Lint(ast, findings, excluded_checks_not_found);
	}

	bool Lint() {
	fidl::Findings findings;
	bool passed = Lint(&findings);
	lints_ = fidl::utils::FormatFindings(findings, false);
	return passed;
	}

	std::string GenerateJSON() {
	auto json_generator = fidl::JSONGenerator(library_.get());
	auto out = json_generator.Produce();
	return out.str();
	}

	std::string GenerateTables() {
	auto tables_generator = fidl::TablesGenerator(library_.get());
	auto out = tables_generator.Produce();
	return out.str();
	}

	const fidl::flat::Bits* LookupBits(const std::string& name) {
	for (const auto& bits_decl : library_->bits_declarations_) {
	if (bits_decl->GetName() == name) {
	return bits_decl.get();
	}
	}
	return nullptr;
	}

	const fidl::flat::Const* LookupConstant(const std::string& name) {
	for (const auto& const_decl : library_->const_declarations_) {
	if (const_decl->GetName() == name) {
	return const_decl.get();
	}
	}
	return nullptr;
	}

	const fidl::flat::Enum* LookupEnum(const std::string& name) {
	for (const auto& enum_decl : library_->enum_declarations_) {
	if (enum_decl->GetName() == name) {
	return enum_decl.get();
	}
	}
	return nullptr;
	}

	const fidl::flat::Resource* LookupResource(const std::string& name) {
	for (const auto& resource_decl : library_->resource_declarations_) {
	if (resource_decl->GetName() == name) {
	return resource_decl.get();
	}
	}
	return nullptr;
	}

	const fidl::flat::Service* LookupService(const std::string& name) {
	for (const auto& service_decl : library_->service_declarations_) {
	if (service_decl->GetName() == name) {
	return service_decl.get();
	}
	}
	return nullptr;
	}

	const fidl::flat::Struct* LookupStruct(const std::string& name) {
	for (const auto& struct_decl : library_->struct_declarations_) {
	if (struct_decl->GetName() == name) {
	return struct_decl.get();
	}
	}
	return nullptr;
	}

	const fidl::flat::Table* LookupTable(const std::string& name) {
	for (const auto& table_decl : library_->table_declarations_) {
	if (table_decl->GetName() == name) {
	return table_decl.get();
	}
	}
	return nullptr;
	}

	const fidl::flat::TypeAlias* LookupTypeAlias(const std::string& name) {
	for (const auto& type_alias_decl : library_->type_alias_declarations_) {
	if (type_alias_decl->GetName() == name) {
	return type_alias_decl.get();
	}
	}
	return nullptr;
	}

	const fidl::flat::Union* LookupUnion(const std::string& name) {
	for (const auto& union_decl : library_->union_declarations_) {
	if (union_decl->GetName() == name) {
	return union_decl.get();
	}
	}
	return nullptr;
	}

	const fidl::flat::Protocol* LookupProtocol(const std::string& name) {
	for (const auto& protocol_decl : library_->protocol_declarations_) {
	if (protocol_decl->GetName() == name) {
	return protocol_decl.get();
	}
	}
	return nullptr;
	}

	void set_warnings_as_errors(bool value) { reporter_->set_warnings_as_errors(value); }

	const fidl::flat::Library* library() const { return library_.get(); }

	const fidl::SourceFile& source_file() const {
	assert(all_sources_.size() == 1 && "convenience method only possible with single source");
	return *all_sources_.at(0);
	}

	fidl::SourceSpan source_span(size_t start, size_t size) const {
	assert(all_sources_.size() == 1 && "convenience method only possible with single source");
	std::string_view data = all_sources_.at(0)->data();
	data.remove_prefix(start);
	data.remove_suffix(data.size() - size);
	return fidl::SourceSpan(data, *all_sources_.at(0));
	}

	std::vector<fidl::Diagnostic*> diagnostics() const { return reporter_->diagnostics(); }

	const std::vector<std::unique_ptr<fidl::Diagnostic>>& errors() const {
	return reporter_->errors();
	}

	const std::vector<std::unique_ptr<fidl::Diagnostic>>& warnings() const {
	return reporter_->warnings();
	}

	const std::vector<std::string>& lints() const { return lints_; }

	const std::vector<fidl::flat::Decl*> declaration_order() const {
	return library_->declaration_order_;
	}

	protected:
	SharedAmongstLibraries owned_shared_;
	fidl::Reporter* reporter_;
	std::vector<std::string> lints_;
	fidl::ExperimentalFlags experimental_flags_;
	fidl::flat::Typespace* typespace_;
	fidl::flat::Libraries* all_libraries_;
	std::vector<std::unique_ptr<fidl::SourceFile>>* all_sources_of_all_libraries_;
	std::vector<fidl::SourceFile*> all_sources_;
	std::unique_ptr<fidl::flat::Library> library_;
	};

	#endif // ZIRCON_SYSTEM_UTEST_FIDL_COMPILER_TEST_LIBRARY_H_