tools/aidl/parser.cpp

/*
 * Copyright (C) 2019, 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 "parser.h"

#include <queue>

#include "aidl_language_y.h"
#include "logging.h"

void yylex_init(void**);
void yylex_destroy(void*);
void yyset_in(FILE* f, void*);
int yyparse(Parser*);
YY_BUFFER_STATE yy_scan_buffer(char*, size_t, void*);
void yy_delete_buffer(YY_BUFFER_STATE, void*);

// For each union, generate nested "Tag" enum type so that "Tag" can be used as a valid type.
//    union Foo { int a; int b; } => union Foo { ... enum Tag { a, b }}
struct UnionTagGenerater : AidlVisitor {
  void Visit(const AidlUnionDecl& decl) override {
    std::vector<std::unique_ptr<AidlEnumerator>> enumerators;
    for (const auto& field : decl.GetFields()) {
      auto derived = field->GetLocation().ToDerivedLocation();
      AIDL_FATAL_IF(!derived, field)
          << "Failed to get a derived location. Is this not an external type?";
      enumerators.push_back(std::make_unique<AidlEnumerator>(*derived, field->GetName(), nullptr,
                                                             field->GetComments()));
    }
    auto derived = decl.GetLocation().ToDerivedLocation();
    AIDL_FATAL_IF(!derived, decl)
        << "Failed to get a derived location. Is this not an external type?";
    auto tag_enum = std::make_unique<AidlEnumDeclaration>(*derived, "Tag", &enumerators,
                                                          decl.GetPackage(), Comments{});
    // Tag for @FixedSize union is limited to "byte" type so that it can be passed via FMQ with
    // with lower overhead.
    std::shared_ptr<AidlConstantValue> backing_type{
        AidlConstantValue::String(AIDL_LOCATION_HERE, decl.IsFixedSize() ? "\"byte\"" : "\"int\"")};
    std::vector<std::unique_ptr<AidlAnnotation>> annotations;
    annotations.push_back(
        AidlAnnotation::Parse(AIDL_LOCATION_HERE, "Backing", {{"type", backing_type}}, Comments{}));
    tag_enum->Annotate(std::move(annotations));
    const_cast<AidlUnionDecl&>(decl).AddType(std::move(tag_enum));
  }
};

const AidlDocument* Parser::Parse(const std::string& filename,
                                  const android::aidl::IoDelegate& io_delegate,
                                  AidlTypenames& typenames, bool is_preprocessed) {
  auto clean_path = android::aidl::IoDelegate::CleanPath(filename);
  // reuse pre-parsed document from typenames
  for (auto& doc : typenames.AllDocuments()) {
    if (doc->GetLocation().GetFile() == clean_path) {
      return doc.get();
    }
  }
  // Make sure we can read the file first, before trashing previous state.
  unique_ptr<string> raw_buffer = io_delegate.GetFileContents(clean_path);
  if (raw_buffer == nullptr) {
    AIDL_ERROR(clean_path) << "Error while opening file for parsing";
    return nullptr;
  }

  // We're going to scan this buffer in place, and yacc demands we put two
  // nulls at the end.
  raw_buffer->append(2u, '\0');

  Parser parser(clean_path, *raw_buffer, is_preprocessed);

  if (yy::parser(&parser).parse() != 0 || parser.HasError()) {
    return nullptr;
  }

  // Preprocess parsed document before adding to typenames.
  UnionTagGenerater v;
  VisitTopDown(v, *parser.document_);

  // transfer ownership to AidlTypenames and return the raw pointer
  const AidlDocument* result = parser.document_.get();
  if (!typenames.AddDocument(std::move(parser.document_))) {
    return nullptr;
  }
  return result;
}

void Parser::SetTypeParameters(AidlTypeSpecifier* type,
                               std::vector<std::unique_ptr<AidlTypeSpecifier>>* type_args) {
  if (type->IsArray()) {
    AIDL_ERROR(type) << "Must specify type parameters (<>) before array ([]).";
    AddError();
  }
  if (!type->SetTypeParameters(type_args)) {
    AIDL_ERROR(type) << "Can only specify one set of type parameters.";
    AddError();
    delete type_args;
  }
}

void Parser::CheckValidTypeName(const AidlToken& token, const AidlLocation& loc) {
  if (!is_preprocessed_ && token.GetText().find('.') != std::string::npos) {
    AIDL_ERROR(loc) << "Type name can't be qualified. Use `package`.";
    AddError();
  }
}

void Parser::SetPackage(const std::string& package) {
  if (is_preprocessed_) {
    AIDL_ERROR(package) << "Preprocessed file can't declare package.";
    AddError();
  }
  package_ = package;
}

bool CheckNoRecursiveDefinition(const AidlNode& node) {
  struct Visitor : AidlVisitor {
    enum {
      NOT_STARTED = 0,
      STARTED = 1,
      FINISHED = 2,
    };
    std::map<const AidlParcelable*, int> visited;
    std::vector<std::string> path;
    bool found_cycle = false;

    void Visit(const AidlStructuredParcelable& t) override { FindCycle(&t); }
    void Visit(const AidlUnionDecl& t) override { FindCycle(&t); }
    void Visit(const AidlParcelable& t) override { FindCycle(&t); }

    bool FindCycle(const AidlParcelable* p) {
      // no need to search further
      if (found_cycle) {
        return true;
      }
      // we just found a cycle
      if (visited[p] == STARTED) {
        path.push_back(p->GetName());
        AIDL_ERROR(p) << p->GetName()
                      << " is a recursive parcelable: " << android::base::Join(path, "->");
        return (found_cycle = true);
      }
      // we arrived here with a different route.
      if (visited[p] == FINISHED) {
        return false;
      }
      // start DFS
      visited[p] = STARTED;
      path.push_back(p->GetName());
      for (const auto& f : p->GetFields()) {
        const auto& ref = f->GetType();
        if (!ref.IsArray() && !ref.IsHeapNullable()) {
          const auto& type = ref.GetDefinedType();
          if (type && type->AsParcelable()) {
            if (FindCycle(type->AsParcelable())) {
              return true;
            }
          }
        }
      }
      path.pop_back();
      visited[p] = FINISHED;
      return false;
    }
  } v;
  VisitTopDown(v, node);
  return !v.found_cycle;
}

// Each Visit*() method can use Scope() to get its scope(AidlDefinedType)
class ScopedVisitor : public AidlVisitor {
 protected:
  const AidlDefinedType* Scope() const {
    AIDL_FATAL_IF(scope_.empty(), AIDL_LOCATION_HERE) << "Scope is empty";
    return scope_.back();
  }
  void PushScope(const AidlDefinedType* scope) { scope_.push_back(scope); }
  void PopScope() { scope_.pop_back(); }
  // Keep user defined type as a defining scope
  void VisitScopedTopDown(const AidlNode& node) {
    std::function<void(const AidlNode&)> top_down = [&](const AidlNode& a) {
      a.DispatchVisit(*this);
      auto defined_type = AidlCast<AidlDefinedType>(a);
      if (defined_type) PushScope(defined_type);
      a.TraverseChildren(top_down);
      if (defined_type) PopScope();
    };
    top_down(node);
  }

 private:
  std::vector<const AidlDefinedType*> scope_ = {};
};

class TypeReferenceResolver : public ScopedVisitor {
 public:
  TypeReferenceResolver(TypeResolver& resolver) : resolver_(resolver) {}

  void Visit(const AidlTypeSpecifier& t) override {
    // We're visiting the same node again. This can happen when two constant references
    // point to an ancestor of this node.
    if (t.IsResolved()) {
      return;
    }
    AidlTypeSpecifier& type = const_cast<AidlTypeSpecifier&>(t);
    if (!resolver_(Scope(), &type)) {
      AIDL_ERROR(type) << "Failed to resolve '" << type.GetUnresolvedName() << "'";
      success_ = false;
      return;
    }

    // In case a new document is imported for the type reference, enqueue it for type resolution.
    auto resolved = t.GetDefinedType();
    if (resolved) {
      queue_.push(&resolved->GetDocument());
    }
  }

  bool Resolve(const AidlDocument& document) {
    queue_.push(&document);
    while (!queue_.empty()) {
      auto doc = queue_.front();
      queue_.pop();
      // Skip the doc if it's visited already.
      if (!visited_.insert(doc).second) {
        continue;
      }
      VisitScopedTopDown(*doc);
    }
    return success_;
  }

 private:
  TypeResolver& resolver_;
  bool success_ = true;
  std::queue<const AidlDocument*> queue_ = {};
  std::set<const AidlDocument*> visited_ = {};
};

class ConstantReferenceResolver : public ScopedVisitor {
 public:
  ConstantReferenceResolver() = default;

  void Visit(const AidlConstantReference& v) override {
    if (IsCircularReference(&v)) {
      success_ = false;
      return;
    }

    const AidlConstantValue* resolved = v.Resolve(Scope());
    if (!resolved) {
      AIDL_ERROR(v) << "Unknown reference '" << v.Literal() << "'";
      success_ = false;
      return;
    }

    // On error, skip recursive visiting to avoid redundant messages
    if (!success_) {
      return;
    }
    // resolve recursive references
    PushConstRef(&v);
    VisitScopedTopDown(*resolved);
    PopConstRef();
  }

  bool Resolve(const AidlDocument& document) {
    VisitScopedTopDown(document);
    return success_;
  }

 private:
  void PushConstRef(const AidlConstantReference* ref) {
    stack_.push_back(ref);
    if (ref->GetRefType()) {
      PushScope(ref->GetRefType()->GetDefinedType());
    }
  }

  void PopConstRef() {
    if (stack_.back()->GetRefType()) {
      PopScope();
    }
    stack_.pop_back();
  }

  bool IsCircularReference(const AidlConstantReference* ref) {
    auto it =
        std::find_if(stack_.begin(), stack_.end(), [&](const auto& elem) { return elem == ref; });
    if (it == stack_.end()) {
      return false;
    }
    std::vector<std::string> path;
    while (it != stack_.end()) {
      path.push_back((*it)->Literal());
      ++it;
    }
    path.push_back(ref->Literal());
    AIDL_ERROR(ref) << "Found a circular reference: " << android::base::Join(path, " -> ");
    return true;
  }

  bool success_ = true;
  std::vector<const AidlConstantReference*> stack_ = {};
};

// Resolve references(types/constants) in the "main" document.
bool ResolveReferences(const AidlDocument& document, TypeResolver& type_resolver) {
  // Types are resolved first before resolving constant references so that every referenced document
  // gets imported.
  if (!TypeReferenceResolver(type_resolver).Resolve(document)) {
    return false;
  }
  if (!ConstantReferenceResolver().Resolve(document)) {
    return false;
  }
  if (!CheckNoRecursiveDefinition(document)) {
    return false;
  }
  return true;
}

Parser::Parser(const std::string& filename, std::string& raw_buffer, bool is_preprocessed)
    : filename_(filename), is_preprocessed_(is_preprocessed) {
  yylex_init(&scanner_);
  buffer_ = yy_scan_buffer(&raw_buffer[0], raw_buffer.length(), scanner_);
}

Parser::~Parser() {
  yy_delete_buffer(buffer_, scanner_);
  yylex_destroy(scanner_);
}

void Parser::MakeDocument(const AidlLocation& location, const Comments& comments,
                          std::vector<std::string> imports,
                          std::vector<std::unique_ptr<AidlDefinedType>> defined_types) {
  AIDL_FATAL_IF(document_.get(), location);
  document_ = std::make_unique<AidlDocument>(location, comments, std::move(imports),
                                             std::move(defined_types), is_preprocessed_);
}