diff --git a/AST.cpp b/AST.cpp
index e33fbbf..cb260e2 100644
--- a/AST.cpp
+++ b/AST.cpp
@@ -18,10 +18,10 @@
 
 #include "Coordinator.h"
 #include "EnumType.h"
+#include "FmqType.h"
 #include "HandleType.h"
 #include "Interface.h"
 #include "Location.h"
-#include "FmqType.h"
 #include "Scope.h"
 #include "TypeDef.h"
 
@@ -35,10 +35,11 @@
 
 namespace android {
 
-AST::AST(const Coordinator* coordinator, const std::string& path)
+AST::AST(const Coordinator* coordinator, const Hash* fileHash)
     : mCoordinator(coordinator),
-      mPath(path),
-      mRootScope("(root scope)", Location::startOf(path), nullptr /* parent */) {}
+      mFileHash(fileHash),
+      mRootScope("(root scope)", FQName(), Location::startOf(fileHash->getPath()),
+                 nullptr /* parent */) {}
 
 Scope* AST::getRootScope() {
     return &mRootScope;
@@ -53,13 +54,17 @@
     return mSyntaxErrors;
 }
 
-const std::string &AST::getFilename() const {
-    return mPath;
+const std::string& AST::getFilename() const {
+    return mFileHash->getPath();
+}
+const Hash* AST::getFileHash() const {
+    return mFileHash;
 }
 
 bool AST::setPackage(const char *package) {
-    mPackage.setTo(package);
-    CHECK(mPackage.isValid());
+    if (!mPackage.setTo(package)) {
+        return false;
+    }
 
     if (mPackage.package().empty()
             || mPackage.version().empty()
@@ -82,16 +87,235 @@
     return mRootScope.containsInterfaces();
 }
 
+status_t AST::postParse() {
+    status_t err;
+
+    // lookupTypes is the first pass.
+    err = lookupTypes();
+    if (err != OK) return err;
+    // validateDefinedTypesUniqueNames is the first call
+    // after lookup, as other errors could appear because
+    // user meant different type than we assumed.
+    err = validateDefinedTypesUniqueNames();
+    if (err != OK) return err;
+    // topologicalReorder is before resolveInheritance, as we
+    // need to have no cycle while getting parent class.
+    err = topologicalReorder();
+    if (err != OK) return err;
+    err = resolveInheritance();
+    if (err != OK) return err;
+    err = lookupLocalIdentifiers();
+    if (err != OK) return err;
+    // checkAcyclicConstantExpressions is after resolveInheritance,
+    // as resolveInheritance autofills enum values.
+    err = checkAcyclicConstantExpressions();
+    if (err != OK) return err;
+    err = evaluate();
+    if (err != OK) return err;
+    err = validate();
+    if (err != OK) return err;
+    err = checkForwardReferenceRestrictions();
+    if (err != OK) return err;
+    err = gatherReferencedTypes();
+    if (err != OK) return err;
+
+    // Make future packages not to call passes
+    // for processed types and expressions
+    constantExpressionRecursivePass(
+        [](ConstantExpression* ce) {
+            ce->setPostParseCompleted();
+            return OK;
+        },
+        true /* processBeforeDependencies */);
+    std::unordered_set<const Type*> visited;
+    mRootScope.recursivePass(
+        [](Type* type) {
+            type->setPostParseCompleted();
+            return OK;
+        },
+        &visited);
+
+    return OK;
+}
+
+status_t AST::constantExpressionRecursivePass(
+    const std::function<status_t(ConstantExpression*)>& func, bool processBeforeDependencies) {
+    std::unordered_set<const Type*> visitedTypes;
+    std::unordered_set<const ConstantExpression*> visitedCE;
+    return mRootScope.recursivePass(
+        [&](Type* type) -> status_t {
+            for (auto* ce : type->getConstantExpressions()) {
+                status_t err = ce->recursivePass(func, &visitedCE, processBeforeDependencies);
+                if (err != OK) return err;
+            }
+            return OK;
+        },
+        &visitedTypes);
+}
+
+status_t AST::lookupTypes() {
+    std::unordered_set<const Type*> visited;
+    return mRootScope.recursivePass(
+        [&](Type* type) -> status_t {
+            Scope* scope = type->isScope() ? static_cast<Scope*>(type) : type->parent();
+
+            for (auto* nextRef : type->getReferences()) {
+                if (nextRef->isResolved()) {
+                    continue;
+                }
+
+                Type* nextType = lookupType(nextRef->getLookupFqName(), scope);
+                if (nextType == nullptr) {
+                    std::cerr << "ERROR: Failed to lookup type '"
+                              << nextRef->getLookupFqName().string() << "' at "
+                              << nextRef->location() << "\n";
+                    return UNKNOWN_ERROR;
+                }
+                nextRef->set(nextType);
+            }
+
+            return OK;
+        },
+        &visited);
+}
+
+status_t AST::gatherReferencedTypes() {
+    std::unordered_set<const Type*> visited;
+    return mRootScope.recursivePass(
+        [&](Type* type) -> status_t {
+            for (auto* nextRef : type->getReferences()) {
+                const Type *targetType = nextRef->get();
+                if (targetType->isNamedType()) {
+                    mReferencedTypeNames.insert(
+                            static_cast<const NamedType *>(targetType)->fqName());
+                }
+            }
+
+            return OK;
+        },
+        &visited);
+}
+
+status_t AST::lookupLocalIdentifiers() {
+    std::unordered_set<const Type*> visitedTypes;
+    std::unordered_set<const ConstantExpression*> visitedCE;
+
+    return mRootScope.recursivePass(
+        [&](Type* type) -> status_t {
+            Scope* scope = type->isScope() ? static_cast<Scope*>(type) : type->parent();
+
+            for (auto* ce : type->getConstantExpressions()) {
+                status_t err = ce->recursivePass(
+                    [&](ConstantExpression* ce) {
+                        for (auto* nextRef : ce->getReferences()) {
+                            if (nextRef->isResolved()) continue;
+
+                            LocalIdentifier* iden = lookupLocalIdentifier(*nextRef, scope);
+                            if (iden == nullptr) return UNKNOWN_ERROR;
+                            nextRef->set(iden);
+                        }
+                        return OK;
+                    },
+                    &visitedCE, true /* processBeforeDependencies */);
+                if (err != OK) return err;
+            }
+
+            return OK;
+        },
+        &visitedTypes);
+}
+
+status_t AST::validateDefinedTypesUniqueNames() const {
+    std::unordered_set<const Type*> visited;
+    return mRootScope.recursivePass(
+        [&](const Type* type) -> status_t {
+            // We only want to validate type definition names in this place.
+            if (type->isScope()) {
+                return static_cast<const Scope*>(type)->validateUniqueNames();
+            }
+            return OK;
+        },
+        &visited);
+}
+
+status_t AST::resolveInheritance() {
+    std::unordered_set<const Type*> visited;
+    return mRootScope.recursivePass(&Type::resolveInheritance, &visited);
+}
+
+status_t AST::evaluate() {
+    return constantExpressionRecursivePass(
+        [](ConstantExpression* ce) {
+            ce->evaluate();
+            return OK;
+        },
+        false /* processBeforeDependencies */);
+}
+
+status_t AST::validate() const {
+    std::unordered_set<const Type*> visited;
+    return mRootScope.recursivePass(&Type::validate, &visited);
+}
+
+status_t AST::topologicalReorder() {
+    std::unordered_map<const Type*, size_t> reversedOrder;
+    std::unordered_set<const Type*> stack;
+    status_t err = mRootScope.topologicalOrder(&reversedOrder, &stack).status;
+    if (err != OK) return err;
+
+    std::unordered_set<const Type*> visited;
+    mRootScope.recursivePass(
+        [&](Type* type) {
+            if (type->isScope()) {
+                static_cast<Scope*>(type)->topologicalReorder(reversedOrder);
+            }
+            return OK;
+        },
+        &visited);
+    return OK;
+}
+
+status_t AST::checkAcyclicConstantExpressions() const {
+    std::unordered_set<const Type*> visitedTypes;
+    std::unordered_set<const ConstantExpression*> visitedCE;
+    std::unordered_set<const ConstantExpression*> stack;
+    return mRootScope.recursivePass(
+        [&](const Type* type) -> status_t {
+            for (auto* ce : type->getConstantExpressions()) {
+                status_t err = ce->checkAcyclic(&visitedCE, &stack).status;
+                CHECK(err != OK || stack.empty());
+                if (err != OK) return err;
+            }
+            return OK;
+        },
+        &visitedTypes);
+}
+
+status_t AST::checkForwardReferenceRestrictions() const {
+    std::unordered_set<const Type*> visited;
+    return mRootScope.recursivePass(
+        [](const Type* type) -> status_t {
+            for (const Reference<Type>* ref : type->getReferences()) {
+                status_t err = type->checkForwardReferenceRestrictions(*ref);
+                if (err != OK) return err;
+            }
+            return OK;
+        },
+        &visited);
+}
+
 bool AST::addImport(const char *import) {
-    FQName fqName(import);
-    CHECK(fqName.isValid());
+    FQName fqName;
+    if (!FQName::parse(import, &fqName)) {
+        std::cerr << "ERROR: '" << import << "' is an invalid fully-qualified name." << std::endl;
+        return false;
+    }
 
     fqName.applyDefaults(mPackage.package(), mPackage.version());
 
-    // LOG(INFO) << "importing " << fqName.string();
-
     if (fqName.name().empty()) {
         // import a package
+
         std::vector<FQName> packageInterfaces;
 
         status_t err =
@@ -103,6 +327,8 @@
         }
 
         for (const auto &subFQName : packageInterfaces) {
+            addToImportedNamesGranular(subFQName);
+
             // Do not enforce restrictions on imports.
             AST* ast = mCoordinator->parse(subFQName, &mImportedASTs, Coordinator::Enforce::NONE);
             if (ast == nullptr) {
@@ -115,7 +341,7 @@
         return true;
     }
 
-    AST *importAST;
+    addToImportedNamesGranular(fqName);
 
     // cases like android.hardware.foo@1.0::IFoo.Internal
     //            android.hardware.foo@1.0::Abc.Internal
@@ -123,7 +349,11 @@
     // assume it is an interface, and try to import it.
     const FQName interfaceName = fqName.getTopLevelType();
     // Do not enforce restrictions on imports.
-    importAST = mCoordinator->parse(interfaceName, &mImportedASTs, Coordinator::Enforce::NONE);
+    AST* importAST;
+    status_t err = mCoordinator->parseOptional(interfaceName, &importAST, &mImportedASTs,
+                                               Coordinator::Enforce::NONE);
+    if (err != OK) return false;
+    // importAST nullptr == file doesn't exist
 
     if (importAST != nullptr) {
         // cases like android.hardware.foo@1.0::IFoo.Internal
@@ -175,25 +405,8 @@
     mImportedASTs.insert(ast);
 }
 
-bool AST::addTypeDef(const char* localName, Type* type, const Location& location,
-                     std::string* errorMsg, Scope* scope) {
-    // The reason we wrap the given type in a TypeDef is simply to suppress
-    // emitting any type definitions later on, since this is just an alias
-    // to a type defined elsewhere.
-    return addScopedTypeInternal(new TypeDef(localName, location, scope, type), errorMsg, scope);
-}
-
-bool AST::addScopedType(NamedType* type, std::string* errorMsg, Scope* scope) {
-    return addScopedTypeInternal(type, errorMsg, scope);
-}
-
-bool AST::addScopedTypeInternal(NamedType* type, std::string* errorMsg, Scope* scope) {
-    bool success = scope->addType(type, errorMsg);
-    if (!success) {
-        return false;
-    }
-
-    std::vector<std::string> pathComponents{{type->localName()}};
+FQName AST::makeFullName(const char* localName, Scope* scope) const {
+    std::vector<std::string> pathComponents{{localName}};
     for (; scope != &mRootScope; scope = scope->parent()) {
         pathComponents.push_back(scope->localName());
     }
@@ -201,12 +414,34 @@
     std::reverse(pathComponents.begin(), pathComponents.end());
     std::string path = StringHelper::JoinStrings(pathComponents, ".");
 
-    FQName fqName(mPackage.package(), mPackage.version(), path);
-    type->setFullName(fqName);
+    return FQName(mPackage.package(), mPackage.version(), path);
+}
 
-    mDefinedTypesByFullName[fqName] = type;
+void AST::addScopedType(NamedType* type, Scope* scope) {
+    scope->addType(type);
+    mDefinedTypesByFullName[type->fqName()] = type;
+}
 
-    return true;
+LocalIdentifier* AST::lookupLocalIdentifier(const Reference<LocalIdentifier>& ref, Scope* scope) {
+    const FQName& fqName = ref.getLookupFqName();
+
+    if (fqName.isIdentifier()) {
+        LocalIdentifier* iden = scope->lookupIdentifier(fqName.name());
+        if (iden == nullptr) {
+            std::cerr << "ERROR: identifier " << fqName.string() << " could not be found at "
+                      << ref.location() << "\n";
+            return nullptr;
+        }
+        return iden;
+    } else {
+        std::string errorMsg;
+        EnumValue* enumValue = lookupEnumValue(fqName, &errorMsg, scope);
+        if (enumValue == nullptr) {
+            std::cerr << "ERROR: " << errorMsg << " at " << ref.location() << "\n";
+            return nullptr;
+        }
+        return enumValue;
+    }
 }
 
 EnumValue* AST::lookupEnumValue(const FQName& fqName, std::string* errorMsg, Scope* scope) {
@@ -221,6 +456,7 @@
         *errorMsg = "Cannot find type " + enumTypeName.string();
         return nullptr;
     }
+    type = type->resolve();
     if(!type->isEnum()) {
         *errorMsg = "Type " + enumTypeName.string() + " is not an enum type";
         return nullptr;
@@ -232,6 +468,9 @@
         *errorMsg = "Enum type " + enumTypeName.string() + " does not have " + enumValueName;
         return nullptr;
     }
+
+    mReferencedTypeNames.insert(enumType->fqName());
+
     return v;
 }
 
@@ -253,14 +492,12 @@
         }
     }
 
-    if (!fqName.isFullyQualified()) {
-        status_t status = lookupAutofilledType(fqName, &returnedType);
-        if (status != OK) {
-            return nullptr;
-        }
-        if (returnedType != nullptr) {
-            return returnedType;
-        }
+    status_t status = lookupAutofilledType(fqName, &returnedType);
+    if (status != OK) {
+        return nullptr;
+    }
+    if (returnedType != nullptr) {
+        return returnedType;
     }
 
     return lookupTypeFromImports(fqName);
@@ -273,13 +510,7 @@
 
     for (; scope != nullptr; scope = scope->parent()) {
         Type* type = scope->lookupType(fqName);
-
         if (type != nullptr) {
-            // Resolve typeDefs to the target type.
-            while (type->isTypeDef()) {
-                type = static_cast<TypeDef *>(type)->referencedType();
-            }
-
             return type;
         }
     }
@@ -289,7 +520,7 @@
 
 // Rule 1: auto-fill with current package
 status_t AST::lookupAutofilledType(const FQName &fqName, Type **returnedType) {
-    CHECK(!fqName.isFullyQualified() && !fqName.name().empty() && fqName.valueName().empty());
+    CHECK(!fqName.name().empty() && fqName.valueName().empty());
 
     FQName autofilled = fqName;
     autofilled.applyDefaults(mPackage.package(), mPackage.version());
@@ -298,7 +529,7 @@
     // in import.
     Type *local = findDefinedType(autofilled, &matchingName);
     CHECK(local == nullptr || autofilled == matchingName);
-    Type* fromImport = lookupType(autofilled, nullptr /* scope */);
+    Type* fromImport = lookupTypeFromImports(autofilled);
 
     if (local != nullptr && fromImport != nullptr && local != fromImport) {
         // Something bad happen; two types have the same FQName.
@@ -382,20 +613,6 @@
     }
 
     if (resolvedType) {
-#if 0
-        LOG(INFO) << "found '"
-                  << resolvedName.string()
-                  << "' after looking for '"
-                  << fqName.string()
-                  << "'.";
-#endif
-
-        // Resolve typeDefs to the target type.
-        while (resolvedType->isTypeDef()) {
-            resolvedType =
-                static_cast<TypeDef *>(resolvedType)->referencedType();
-        }
-
         returnedType = resolvedType;
 
         // If the resolved type is not an interface, we need to determine
@@ -444,14 +661,26 @@
             // in turn referenced the found interface we'd mistakenly use the
             // name of the typedef instead of the proper name of the interface.
 
-            mImportedNames.insert(
-                    static_cast<Interface *>(resolvedType)->fqName());
+            const FQName &typeName =
+                static_cast<Interface *>(resolvedType)->fqName();
+
+            mImportedNames.insert(typeName);
         }
     }
 
     return returnedType;
 }
 
+void AST::addToImportedNamesGranular(const FQName &fqName) {
+    if (fqName.package() == package().package()
+            && fqName.version() == package().version()) {
+        // Our own names are _defined_ here, not imported.
+        return;
+    }
+
+    mImportedNamesGranular.insert(fqName);
+}
+
 Type *AST::findDefinedType(const FQName &fqName, FQName *matchingName) const {
     for (const auto &pair : mDefinedTypesByFullName) {
         const FQName &key = pair.first;
@@ -467,7 +696,7 @@
 }
 
 void AST::getImportedPackages(std::set<FQName> *importSet) const {
-    for (const auto &fqName : mImportedNames) {
+    for (const auto& fqName : mImportedNamesGranular) {
         FQName packageName = fqName.getPackageAndVersion();
 
         if (packageName == mPackage) {
@@ -481,6 +710,7 @@
 
 void AST::getImportedPackagesHierarchy(std::set<FQName> *importSet) const {
     getImportedPackages(importSet);
+
     std::set<FQName> newSet;
     for (const auto &ast : mImportedASTs) {
         if (importSet->find(ast->package()) != importSet->end()) {
@@ -498,19 +728,23 @@
     }
 }
 
-bool AST::isJavaCompatible() const {
-    if (!AST::isInterface()) {
-        for (const auto* type : mRootScope.getSubTypes()) {
-            if (!type->isJavaCompatible()) {
-                return false;
-            }
+void AST::getAllImportedNamesGranular(std::set<FQName> *allImportNames) const {
+    for (const auto& fqName : mImportedNamesGranular) {
+        if (fqName.name() == "types") {
+            // A package will export everything _defined_ but will not
+            // re-export anything it itself imported.
+            AST* ast = mCoordinator->parse(
+                    fqName, nullptr /* imported */, Coordinator::Enforce::NONE);
+
+            ast->addDefinedTypes(allImportNames);
+        } else {
+            allImportNames->insert(fqName);
         }
-
-        return true;
     }
+}
 
-    const Interface* iface = mRootScope.getInterface();
-    return iface->isJavaCompatible();
+bool AST::isJavaCompatible() const {
+    return mRootScope.isJavaCompatible();
 }
 
 void AST::appendToExportedTypesVector(
@@ -533,4 +767,24 @@
     return iface ? iface->getBaseName() : "types";
 }
 
+void AST::addDefinedTypes(std::set<FQName> *definedTypes) const {
+    std::for_each(
+            mDefinedTypesByFullName.begin(),
+            mDefinedTypesByFullName.end(),
+            [definedTypes](const auto &elem) {
+                if (!elem.second->isTypeDef()) {
+                    definedTypes->insert(elem.first);
+                }
+            });
+}
+
+void AST::addReferencedTypes(std::set<FQName> *referencedTypes) const {
+    std::for_each(
+            mReferencedTypeNames.begin(),
+            mReferencedTypeNames.end(),
+            [referencedTypes](const auto &fqName) {
+                referencedTypes->insert(fqName);
+            });
+}
+
 }  // namespace android;
diff --git a/AST.h b/AST.h
index 6ef0ed3..4de98bd 100644
--- a/AST.h
+++ b/AST.h
@@ -19,7 +19,9 @@
 #define AST_H_
 
 #include <android-base/macros.h>
+#include <hidl-hash/Hash.h>
 #include <hidl-util/FQName.h>
+#include <functional>
 #include <map>
 #include <set>
 #include <string>
@@ -31,16 +33,19 @@
 namespace android {
 
 struct Coordinator;
+struct ConstantExpression;
+struct EnumValue;
 struct Formatter;
 struct Interface;
 struct Location;
 struct Method;
 struct NamedType;
-struct TypedVar;
-struct EnumValue;
+template <class T>
+struct NamedReference;
+struct Type;
 
 struct AST {
-    AST(const Coordinator *coordinator, const std::string &path);
+    AST(const Coordinator* coordinator, const Hash* fileHash);
 
     bool setPackage(const char *package);
     bool addImport(const char *import);
@@ -50,14 +55,17 @@
     bool isInterface() const;
     bool containsInterfaces() const;
 
-    // Returns true iff successful.
-    bool addTypeDef(const char* localName, Type* type, const Location& location,
-                    std::string* errorMsg, Scope* scope);
+    // Adds package, version and scope stack to local name
+    FQName makeFullName(const char* localName, Scope* scope) const;
 
-    // Returns true iff successful.
-    bool addScopedType(NamedType* type, std::string* errorMsg, Scope* scope);
+    void addScopedType(NamedType* type, Scope* scope);
 
-    const std::string &getFilename() const;
+    const std::string& getFilename() const;
+    const Hash* getFileHash() const;
+
+    // Look up local identifier.
+    // It could be plain identifier or enum value as described by lookupEnumValue.
+    LocalIdentifier* lookupLocalIdentifier(const Reference<LocalIdentifier>& ref, Scope* scope);
 
     // Look up an enum value by "FQName:valueName".
     EnumValue* lookupEnumValue(const FQName& fqName, std::string* errorMsg, Scope* scope);
@@ -69,20 +77,66 @@
 
     void addImportedAST(AST *ast);
 
-    status_t generateCpp(const std::string &outputPath) const;
-    status_t generateCppHeaders(const std::string &outputPath) const;
-    status_t generateCppSources(const std::string &outputPath) const;
-    status_t generateCppImpl(const std::string &outputPath) const;
-    status_t generateStubImplHeader(const std::string& outputPath) const;
-    status_t generateStubImplSource(const std::string& outputPath) const;
+    // Calls all passes after parsing required before
+    // being ready to generate output.
+    status_t postParse();
 
-    status_t generateJava(
-            const std::string &outputPath,
-            const std::string &limitToType) const;
+    // Recursive pass on constant expression tree
+    status_t constantExpressionRecursivePass(
+        const std::function<status_t(ConstantExpression*)>& func, bool processBeforeDependencies);
 
-    status_t generateJavaTypes(
-            const std::string &outputPath,
-            const std::string &limitToType) const;
+    // Recursive tree pass that looks up all referenced types
+    status_t lookupTypes();
+
+    // Recursive tree pass that looks up all referenced local identifiers
+    status_t lookupLocalIdentifiers();
+
+    // Recursive tree pass that validates that all defined types
+    // have unique names in their scopes.
+    status_t validateDefinedTypesUniqueNames() const;
+
+    // Recursive tree pass that completes type declarations
+    // that depend on super types
+    status_t resolveInheritance();
+
+    // Recursive tree pass that evaluates constant expressions
+    status_t evaluate();
+
+    // Recursive tree pass that validates all type-related
+    // syntax restrictions
+    status_t validate() const;
+
+    // Recursive tree pass that ensures that type definitions and references
+    // are acyclic and reorderes type definitions in reversed topological order.
+    status_t topologicalReorder();
+
+    // Recursive tree pass that ensures that constant expressions
+    // are acyclic.
+    status_t checkAcyclicConstantExpressions() const;
+
+    // Recursive tree pass that checks C++ forward declaration restrictions.
+    status_t checkForwardReferenceRestrictions() const;
+
+    status_t gatherReferencedTypes();
+
+    void generateCppSource(Formatter& out) const;
+
+    void generateInterfaceHeader(Formatter& out) const;
+    void generateHwBinderHeader(Formatter& out) const;
+    void generateStubHeader(Formatter& out) const;
+    void generateProxyHeader(Formatter& out) const;
+    void generatePassthroughHeader(Formatter& out) const;
+
+    void generateCppImplHeader(Formatter& out) const;
+    void generateCppImplSource(Formatter& out) const;
+
+    void generateCppAdapterHeader(Formatter& out) const;
+    void generateCppAdapterSource(Formatter& out) const;
+
+    void generateJava(Formatter& out, const std::string& limitToType) const;
+    void generateJavaTypes(Formatter& out, const std::string& limitToType) const;
+
+    void generateVts(Formatter& out) const;
 
     void getImportedPackages(std::set<FQName> *importSet) const;
 
@@ -90,19 +144,25 @@
     // each AST in each package referenced in importSet.
     void getImportedPackagesHierarchy(std::set<FQName> *importSet) const;
 
-    status_t generateVts(const std::string &outputPath) const;
-
     bool isJavaCompatible() const;
 
-    // Return the set of FQNames for those interfaces and types that are
-    // actually referenced in the AST, not merely imported.
-    const std::set<FQName>& getImportedNames() const {
-        return mImportedNames;
-    }
-
-    // Get transitive closure of imported interface/types.
+    // Warning: this only includes names explicitly referenced in code.
+    //   It does not include all names which are imported.
+    //
+    // Currently, there is one valid usecase for this: importing exactly
+    // the names which need to be imported in generated code. If you import
+    // based on getAllImportedNamesGranular instead, you will import things
+    // that aren't actually used in the resultant code.
+    //
+    // Get transitive closure of imported interface/types. This will add
+    // everything exported by a package even if only a single type from
+    // that package was explicitly imported!
     void getAllImportedNames(std::set<FQName> *allImportSet) const;
 
+    // Get imported types, this includes those explicitly imported as well
+    // as all types defined in imported packages.
+    void getAllImportedNamesGranular(std::set<FQName> *allImportSet) const;
+
     void appendToExportedTypesVector(
             std::vector<const Type *> *exportedTypes) const;
 
@@ -120,9 +180,17 @@
 
     Scope* getRootScope();
 
+    static void generateCppPackageInclude(Formatter& out, const FQName& package,
+                                          const std::string& klass);
+
+    void addDefinedTypes(std::set<FQName> *definedTypes) const;
+    void addReferencedTypes(std::set<FQName> *referencedTypes) const;
+
+    void addToImportedNamesGranular(const FQName &fqName);
+
    private:
-    const Coordinator *mCoordinator;
-    std::string mPath;
+    const Coordinator* mCoordinator;
+    const Hash* mFileHash;
 
     RootScope mRootScope;
 
@@ -130,8 +198,16 @@
 
     // A set of all external interfaces/types that are _actually_ referenced
     // in this AST, this is a subset of those specified in import statements.
+    // Note that this set only resolves to the granularity of either an
+    // interface type or a whole package.
     std::set<FQName> mImportedNames;
 
+    // This is the set of actually imported types.
+    std::set<FQName> mImportedNamesGranular;
+
+    // Warning: this only includes names explicitly referenced in code.
+    //   It does not include all names which are imported.
+    //
     // A set of all ASTs we explicitly or implicitly (types.hal) import.
     std::set<AST *> mImportedASTs;
 
@@ -147,7 +223,7 @@
     // used by the parser.
     size_t mSyntaxErrors = 0;
 
-    bool addScopedTypeInternal(NamedType* type, std::string* errorMsg, Scope* scope);
+    std::set<FQName> mReferencedTypeNames;
 
     // Helper functions for lookupType.
     Type* lookupTypeLocally(const FQName& fqName, Scope* scope);
@@ -164,65 +240,47 @@
     void getPackageAndVersionComponents(
             std::vector<std::string> *components, bool cpp_compatible) const;
 
-    static void generateCppPackageInclude(
-            Formatter &out,
-            const FQName &package,
-            const std::string &klass);
-
     std::string makeHeaderGuard(const std::string &baseName,
                                 bool indicateGenerated = true) const;
     void enterLeaveNamespace(Formatter &out, bool enter) const;
 
     static void generateCheckNonNull(Formatter &out, const std::string &nonNull);
 
-    status_t generateInterfaceHeader(const std::string &outputPath) const;
-    status_t generateHwBinderHeader(const std::string &outputPath) const;
-    status_t generateStubHeader(const std::string &outputPath) const;
-    status_t generateProxyHeader(const std::string &outputPath) const;
-    status_t generatePassthroughHeader(const std::string &outputPath) const;
-
-    status_t generateTypeSource(
-            Formatter &out, const std::string &ifaceName) const;
+    void generateTypeSource(Formatter& out, const std::string& ifaceName) const;
 
     // a method, and in which interface is it originally defined.
     // be careful of the case where method.isHidlReserved(), where interface
     // is effectively useless.
-    using MethodGenerator = std::function<status_t(const Method *, const Interface *)>;
+    using MethodGenerator = std::function<void(const Method*, const Interface*)>;
 
     void generateTemplatizationLink(Formatter& out) const;
+    void generateCppTag(Formatter& out, const std::string& tag) const;
 
-    status_t generateMethods(Formatter &out, MethodGenerator gen, bool includeParents = true) const;
-    status_t generateStubImplMethod(Formatter &out,
-                                    const std::string &className,
-                                    const Method *method) const;
-    status_t generatePassthroughMethod(Formatter &out,
-                                       const Method *method) const;
-    status_t generateStaticProxyMethodSource(Formatter &out,
-                                             const std::string &className,
-                                             const Method *method) const;
-    status_t generateProxyMethodSource(Formatter &out,
-                                       const std::string &className,
-                                       const Method *method,
-                                       const Interface *superInterface) const;
+    void generateMethods(Formatter& out, const MethodGenerator& gen,
+                         bool includeParents = true) const;
+    void generateStubImplMethod(Formatter& out, const std::string& className,
+                                const Method* method) const;
+    void generatePassthroughMethod(Formatter& out, const Method* method) const;
+    void generateStaticProxyMethodSource(Formatter& out, const std::string& className,
+                                         const Method* method) const;
+    void generateProxyMethodSource(Formatter& out, const std::string& className,
+                                   const Method* method, const Interface* superInterface) const;
+    void generateAdapterMethod(Formatter& out, const Method* method) const;
 
     void generateFetchSymbol(Formatter &out, const std::string &ifaceName) const;
 
-    status_t generateProxySource(
-            Formatter &out, const FQName &fqName) const;
+    void generateProxySource(Formatter& out, const FQName& fqName) const;
 
-    status_t generateStubSource(
-            Formatter &out, const Interface *iface) const;
+    void generateStubSource(Formatter& out, const Interface* iface) const;
 
-    status_t generateStubSourceForMethod(Formatter &out,
-                                         const Method *method,
-                                         const Interface *superInterface) const;
-    status_t generateStaticStubMethodSource(Formatter &out,
-                                            const std::string &className,
-                                            const Method *method) const;
+    void generateStubSourceForMethod(Formatter& out, const Method* method,
+                                     const Interface* superInterface) const;
+    void generateStaticStubMethodSource(Formatter& out, const FQName& fqName,
+                                        const Method* method) const;
 
-    status_t generatePassthroughSource(Formatter &out) const;
+    void generatePassthroughSource(Formatter& out) const;
 
-    status_t generateInterfaceSource(Formatter &out) const;
+    void generateInterfaceSource(Formatter& out) const;
 
     enum InstrumentationEvent {
         SERVER_API_ENTRY = 0,
@@ -247,39 +305,24 @@
             InstrumentationEvent event,
             const Method *method) const;
 
-    void declareCppReaderLocals(
-            Formatter &out,
-            const std::vector<TypedVar *> &arg,
-            bool forResults) const;
+    void declareCppReaderLocals(Formatter& out, const std::vector<NamedReference<Type>*>& arg,
+                                bool forResults) const;
 
-    void emitCppReaderWriter(
-            Formatter &out,
-            const std::string &parcelObj,
-            bool parcelObjIsPointer,
-            const TypedVar *arg,
-            bool isReader,
-            Type::ErrorMode mode,
-            bool addPrefixToName) const;
+    void emitCppReaderWriter(Formatter& out, const std::string& parcelObj, bool parcelObjIsPointer,
+                             const NamedReference<Type>* arg, bool isReader, Type::ErrorMode mode,
+                             bool addPrefixToName) const;
 
-    void emitCppResolveReferences(
-            Formatter &out,
-            const std::string &parcelObj,
-            bool parcelObjIsPointer,
-            const TypedVar *arg,
-            bool isReader,
-            Type::ErrorMode mode,
-            bool addPrefixToName) const;
+    void emitCppResolveReferences(Formatter& out, const std::string& parcelObj,
+                                  bool parcelObjIsPointer, const NamedReference<Type>* arg,
+                                  bool isReader, Type::ErrorMode mode, bool addPrefixToName) const;
 
-    void emitJavaReaderWriter(
-            Formatter &out,
-            const std::string &parcelObj,
-            const TypedVar *arg,
-            bool isReader,
-            bool addPrefixToName) const;
+    void emitJavaReaderWriter(Formatter& out, const std::string& parcelObj,
+                              const NamedReference<Type>* arg, bool isReader,
+                              bool addPrefixToName) const;
 
-    status_t emitTypeDeclarations(Formatter &out) const;
-    status_t emitJavaTypeDeclarations(Formatter &out) const;
-    status_t emitVtsTypeDeclarations(Formatter &out) const;
+    void emitTypeDeclarations(Formatter& out) const;
+    void emitJavaTypeDeclarations(Formatter& out) const;
+    void emitVtsTypeDeclarations(Formatter& out) const;
 
     DISALLOW_COPY_AND_ASSIGN(AST);
 };
diff --git a/Android.bp b/Android.bp
index ef388fc..dd51705 100644
--- a/Android.bp
+++ b/Android.bp
@@ -12,18 +12,16 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-subdirs = [
-    "c2hal",
-    "test",
-    "utils",
-]
-
-hidl_flags = [
-    "-O0",
-    "-g",
-    "-Wall",
-    "-Werror",
-]
+cc_defaults {
+    name: "hidl-gen-defaults",
+    cpp_std: "experimental",
+    cflags: [
+        "-O0",
+        "-g",
+        "-Wall",
+        "-Werror",
+    ],
+}
 
 // This configuration is inherited by all hidl-gen-generated modules.
 cc_defaults {
@@ -31,13 +29,22 @@
     cflags: [
         "-Wall",
         "-Werror",
+        "-Wextra-semi",
     ],
     product_variables: {
         debuggable: {
             cflags: ["-D__ANDROID_DEBUGGABLE__"]
         },
-        treble: {
-            cflags: ["-D__ANDROID_TREBLE__"]
+    },
+}
+
+// This configuration is inherited by all hidl-gen-java modules
+java_defaults {
+    name: "hidl-java-module-defaults",
+    // TODO(b/68433855): allow HIDL java to build in the PDK
+    product_variables: {
+        pdk: {
+            enabled: false,
         },
     },
 }
@@ -48,7 +55,7 @@
 cc_library {
     name: "libhidl-gen-hash",
     host_supported: true,
-    cflags: hidl_flags,
+    defaults: ["hidl-gen-defaults"],
     srcs: ["Hash.cpp"],
     local_include_dirs: ["include_hash/hidl-hash"],
     export_include_dirs: ["include_hash"],
@@ -64,17 +71,19 @@
 //
 cc_library_host_shared {
     name: "libhidl-gen",
-    cflags: hidl_flags,
+    defaults: ["hidl-gen-defaults"],
     srcs: [
         "Annotation.cpp",
         "ArrayType.cpp",
         "CompoundType.cpp",
         "ConstantExpression.cpp",
         "DeathRecipientType.cpp",
+        "DocComment.cpp",
         "EnumType.cpp",
         "HandleType.cpp",
         "HidlTypeAssertion.cpp",
         "Interface.cpp",
+        "Location.cpp",
         "MemoryType.cpp",
         "Method.cpp",
         "NamedType.cpp",
@@ -94,6 +103,11 @@
         "libhidl-gen-hash",
         "libhidl-gen-utils",
     ],
+    export_shared_lib_headers: [
+        "libbase",
+        "libhidl-gen-utils",
+    ],
+    export_include_dirs: ["."], // for tests
 }
 
 //
@@ -102,10 +116,11 @@
 
 cc_library_host_shared {
     name: "libhidl-gen-ast",
-    cflags: hidl_flags,
+    defaults: ["hidl-gen-defaults"],
     srcs: [
         "Coordinator.cpp",
         "generateCpp.cpp",
+        "generateCppAdapter.cpp",
         "generateCppImpl.cpp",
         "generateJava.cpp",
         "generateVts.cpp",
@@ -120,6 +135,11 @@
         "libhidl-gen-hash",
         "libhidl-gen-utils",
     ],
+    export_shared_lib_headers: [
+        "libbase",
+        "libhidl-gen-utils",
+    ],
+    export_include_dirs: ["."], // for tests
 }
 
 //
@@ -127,7 +147,7 @@
 //
 cc_binary_host {
     name: "hidl-gen",
-    cflags: hidl_flags,
+    defaults: ["hidl-gen-defaults"],
     srcs: ["main.cpp"],
     shared_libs: [
         "libbase",
diff --git a/Annotation.cpp b/Annotation.cpp
index a3e49f8..e5a66b0 100644
--- a/Annotation.cpp
+++ b/Annotation.cpp
@@ -19,35 +19,27 @@
 #include <android-base/logging.h>
 #include <hidl-util/Formatter.h>
 #include <hidl-util/StringHelper.h>
+#include <algorithm>
 #include <vector>
 
 namespace android {
 
+AnnotationParam::AnnotationParam(const std::string& name) : mName(name) {}
 
-AnnotationParam::AnnotationParam(const std::string &name,
-                std::vector<std::string> *values)
-: mName(name), mValues(values) {}
-
-AnnotationParam::AnnotationParam(const std::string &name,
-                std::vector<ConstantExpression *> *values)
-        : mName(name) {
-    mValues = new std::vector<std::string>();
-    for(ConstantExpression *ce : *values) {
-        mValues->push_back(ce->value() + " /* " + ce->description() + " */");
-    }
-}
-
-const std::string &AnnotationParam::getName() const {
+const std::string& AnnotationParam::getName() const {
     return mName;
 }
 
-const std::vector<std::string> *AnnotationParam::getValues() const {
-    return mValues;
+std::vector<ConstantExpression*> AnnotationParam::getConstantExpressions() {
+    const auto& constRet = static_cast<const AnnotationParam*>(this)->getConstantExpressions();
+    std::vector<ConstantExpression*> ret(constRet.size());
+    std::transform(constRet.begin(), constRet.end(), ret.begin(),
+                   [](const auto* ce) { return const_cast<ConstantExpression*>(ce); });
+    return ret;
 }
 
-const std::string &AnnotationParam::getSingleValue() const {
-    CHECK_EQ(mValues->size(), 1u) << mName << " requires one values but has multiple";
-    return mValues->at(0);
+std::vector<const ConstantExpression*> AnnotationParam::getConstantExpressions() const {
+    return {};
 }
 
 std::string AnnotationParam::getSingleString() const {
@@ -75,11 +67,53 @@
     return false;
 }
 
-Annotation::Annotation(const char *name,AnnotationParamVector *params)
-        : mName(name),
-          mParams(params) {
+StringAnnotationParam::StringAnnotationParam(const std::string& name,
+                                             std::vector<std::string>* values)
+    : AnnotationParam(name), mValues(values) {}
+
+std::vector<std::string> StringAnnotationParam::getValues() const {
+    return *mValues;
 }
 
+std::string StringAnnotationParam::getSingleValue() const {
+    CHECK_EQ(mValues->size(), 1u) << mName << " requires one value but has multiple";
+    return mValues->at(0);
+}
+
+ConstantExpressionAnnotationParam::ConstantExpressionAnnotationParam(
+    const std::string& name, std::vector<ConstantExpression*>* values)
+    : AnnotationParam(name), mValues(values) {}
+
+std::string convertToString(const ConstantExpression* value) {
+    if (value->descriptionIsTrivial()) {
+        return value->value();
+    }
+    return value->value() + " /* " + value->description() + " */";
+}
+
+std::vector<std::string> ConstantExpressionAnnotationParam::getValues() const {
+    std::vector<std::string> ret;
+    for (const auto* value : *mValues) {
+        ret.push_back(convertToString(value));
+    };
+    return ret;
+}
+
+std::string ConstantExpressionAnnotationParam::getSingleValue() const {
+    CHECK_EQ(mValues->size(), 1u) << mName << " requires one value but has multiple";
+    return convertToString(mValues->at(0));
+}
+
+std::vector<const ConstantExpression*> ConstantExpressionAnnotationParam::getConstantExpressions()
+    const {
+    std::vector<const ConstantExpression*> ret;
+    ret.insert(ret.end(), mValues->begin(), mValues->end());
+    return ret;
+}
+
+Annotation::Annotation(const char* name, AnnotationParamVector* params)
+    : mName(name), mParams(params) {}
+
 std::string Annotation::name() const {
     return mName;
 }
@@ -89,7 +123,7 @@
 }
 
 const AnnotationParam *Annotation::getParam(const std::string &name) const {
-    for (auto *i: *mParams) {
+    for (const auto* i : *mParams) {
         if (i->getName() == name) {
             return i;
         }
@@ -98,6 +132,23 @@
     return nullptr;
 }
 
+std::vector<ConstantExpression*> Annotation::getConstantExpressions() {
+    const auto& constRet = static_cast<const Annotation*>(this)->getConstantExpressions();
+    std::vector<ConstantExpression*> ret(constRet.size());
+    std::transform(constRet.begin(), constRet.end(), ret.begin(),
+                   [](const auto* ce) { return const_cast<ConstantExpression*>(ce); });
+    return ret;
+}
+
+std::vector<const ConstantExpression*> Annotation::getConstantExpressions() const {
+    std::vector<const ConstantExpression*> ret;
+    for (const auto* param : *mParams) {
+        const auto& retParam = param->getConstantExpressions();
+        ret.insert(ret.end(), retParam.begin(), retParam.end());
+    }
+    return ret;
+}
+
 void Annotation::dump(Formatter &out) const {
     out << "@" << mName;
 
@@ -116,14 +167,14 @@
 
         out << param->getName() << "=";
 
-        const std::vector<std::string> *values = param->getValues();
-        if (values->size() > 1) {
+        const std::vector<std::string>& values = param->getValues();
+        if (values.size() > 1) {
             out << "{";
         }
 
-        out << StringHelper::JoinStrings(*values, ", ");
+        out << StringHelper::JoinStrings(values, ", ");
 
-        if (values->size() > 1) {
+        if (values.size() > 1) {
             out << "}";
         }
     }
diff --git a/Annotation.h b/Annotation.h
index 18d9ab0..dfeb59e 100644
--- a/Annotation.h
+++ b/Annotation.h
@@ -21,6 +21,7 @@
 #include <android-base/macros.h>
 #include <map>
 #include <string>
+#include <vector>
 
 #include "ConstantExpression.h"
 
@@ -29,15 +30,12 @@
 struct Formatter;
 
 struct AnnotationParam {
-    AnnotationParam(const std::string &name,
-                    std::vector<std::string> *values);
-    AnnotationParam(const std::string &name,
-                    std::vector<ConstantExpression *> *values);
+    virtual ~AnnotationParam() {}
 
-    const std::string &getName() const;
-    const std::vector<std::string> *getValues() const;
+    const std::string& getName() const;
 
-    const std::string &getSingleValue() const;
+    virtual std::vector<std::string> getValues() const = 0;
+    virtual std::string getSingleValue() const = 0;
 
     /* Returns unquoted version of getSingleValue */
     std::string getSingleString() const;
@@ -45,12 +43,39 @@
     /* Returns value interpretted as a boolean */
     bool getSingleBool() const;
 
-private:
+    std::vector<ConstantExpression*> getConstantExpressions();
+    virtual std::vector<const ConstantExpression*> getConstantExpressions() const;
+
+   protected:
     const std::string mName;
-    std::vector<std::string> *mValues;
+
+    AnnotationParam(const std::string& name);
 };
 
-using AnnotationParamVector = std::vector<const AnnotationParam*>;
+struct StringAnnotationParam : AnnotationParam {
+    StringAnnotationParam(const std::string& name, std::vector<std::string>* values);
+
+    std::vector<std::string> getValues() const override;
+    std::string getSingleValue() const override;
+
+   private:
+    std::vector<std::string>* const mValues;
+};
+
+struct ConstantExpressionAnnotationParam : AnnotationParam {
+    ConstantExpressionAnnotationParam(const std::string& name,
+                                      std::vector<ConstantExpression*>* values);
+
+    std::vector<std::string> getValues() const override;
+    std::string getSingleValue() const override;
+
+    std::vector<const ConstantExpression*> getConstantExpressions() const override;
+
+   private:
+    std::vector<ConstantExpression*>* const mValues;
+};
+
+using AnnotationParamVector = std::vector<AnnotationParam*>;
 
 struct Annotation {
     Annotation(const char *name, AnnotationParamVector *params);
@@ -59,9 +84,12 @@
     const AnnotationParamVector &params() const;
     const AnnotationParam *getParam(const std::string &name) const;
 
+    std::vector<ConstantExpression*> getConstantExpressions();
+    std::vector<const ConstantExpression*> getConstantExpressions() const;
+
     void dump(Formatter &out) const;
 
-private:
+   private:
     std::string mName;
     AnnotationParamVector *mParams;
 
diff --git a/ArrayType.cpp b/ArrayType.cpp
index 382665b..5155a27 100644
--- a/ArrayType.cpp
+++ b/ArrayType.cpp
@@ -16,26 +16,17 @@
 
 #include "ArrayType.h"
 
-#include <hidl-util/Formatter.h>
 #include <android-base/logging.h>
+#include <hidl-util/Formatter.h>
+#include <iostream>
 
 #include "ConstantExpression.h"
 
 namespace android {
 
-ArrayType::ArrayType(ArrayType *srcArray, ConstantExpression *size)
-    : mElementType(srcArray->mElementType),
-      mSizes(srcArray->mSizes) {
-    prependDimension(size);
-}
-
-ArrayType::ArrayType(Type *elementType, ConstantExpression *size)
-    : mElementType(elementType) {
-    prependDimension(size);
-}
-
-void ArrayType::prependDimension(ConstantExpression *size) {
-    mSizes.insert(mSizes.begin(), size);
+ArrayType::ArrayType(const Reference<Type>& elementType, ConstantExpression* size, Scope* parent)
+    : Type(parent), mElementType(elementType), mSizes{size} {
+    CHECK(!elementType.isEmptyReference());
 }
 
 void ArrayType::appendDimension(ConstantExpression *size) {
@@ -50,12 +41,12 @@
     return true;
 }
 
-bool ArrayType::canCheckEquality() const {
-    return mElementType->canCheckEquality();
+bool ArrayType::deepCanCheckEquality(std::unordered_set<const Type*>* visited) const {
+    return mElementType->canCheckEquality(visited);
 }
 
-Type *ArrayType::getElementType() const {
-    return mElementType;
+const Type* ArrayType::getElementType() const {
+    return mElementType.get();
 }
 
 std::string ArrayType::typeName() const {
@@ -66,6 +57,38 @@
     return std::to_string(dimension()) + "d array of " + mElementType->typeName();
 }
 
+std::vector<const Reference<Type>*> ArrayType::getReferences() const {
+    return {&mElementType};
+}
+
+std::vector<const ConstantExpression*> ArrayType::getConstantExpressions() const {
+    std::vector<const ConstantExpression*> ret;
+    ret.insert(ret.end(), mSizes.begin(), mSizes.end());
+    return ret;
+}
+
+status_t ArrayType::resolveInheritance() {
+    // Resolve for typedefs
+    while (mElementType->isArray()) {
+        ArrayType* innerArray = static_cast<ArrayType*>(mElementType.get());
+        mSizes.insert(mSizes.end(), innerArray->mSizes.begin(), innerArray->mSizes.end());
+        mElementType = innerArray->mElementType;
+    }
+    return Type::resolveInheritance();
+}
+
+status_t ArrayType::validate() const {
+    CHECK(!mElementType->isArray());
+
+    if (mElementType->isBinder()) {
+        std::cerr << "ERROR: Arrays of interface types are not supported"
+                  << " at " << mElementType.location() << "\n";
+
+        return UNKNOWN_ERROR;
+    }
+    return Type::validate();
+}
+
 std::string ArrayType::getCppType(StorageMode mode,
                                   bool specifyNamespaces) const {
     const std::string base = mElementType->getCppStackType(specifyNamespaces);
@@ -351,8 +374,11 @@
     return mElementType->needsEmbeddedReadWrite();
 }
 
-bool ArrayType::needsResolveReferences() const {
-    return mElementType->needsResolveReferences();
+bool ArrayType::deepNeedsResolveReferences(std::unordered_set<const Type*>* visited) const {
+    if (mElementType->needsResolveReferences(visited)) {
+        return true;
+    }
+    return Type::deepNeedsResolveReferences(visited);
 }
 
 bool ArrayType::resultNeedsDeref() const {
@@ -434,8 +460,16 @@
     std::string offsetName = "_hidl_array_offset_" + std::to_string(depth);
     out << "long " << offsetName << " = " << offset << ";\n";
 
+    const bool isPrimitiveArray = mElementType->isScalar();
+
+    /* If the element type corresponds to a Java primitive type we can optimize
+       the innermost loop by copying a linear range of memory instead of doing
+       a per-element copy. As a result the outer nested loop does not include
+       the final dimension. */
+    const size_t loopDimensions = mSizes.size() - (isPrimitiveArray ? 1 : 0);
+
     std::string indexString;
-    for (size_t dim = 0; dim < mSizes.size(); ++dim) {
+    for (size_t dim = 0; dim < loopDimensions; ++dim) {
         std::string iteratorName =
             "_hidl_index_" + std::to_string(depth) + "_" + std::to_string(dim);
 
@@ -465,21 +499,57 @@
             << "();\n";
     }
 
-    mElementType->emitJavaFieldReaderWriter(
-            out,
-            depth + 1,
-            parcelName,
-            blobName,
-            fieldName + indexString,
-            offsetName,
-            isReader);
+    if (!isPrimitiveArray) {
+        mElementType->emitJavaFieldReaderWriter(
+                out,
+                depth + 1,
+                parcelName,
+                blobName,
+                fieldName + indexString,
+                offsetName,
+                isReader);
 
-    size_t elementAlign, elementSize;
-    mElementType->getAlignmentAndSize(&elementAlign, &elementSize);
+        size_t elementAlign, elementSize;
+        mElementType->getAlignmentAndSize(&elementAlign, &elementSize);
 
-    out << offsetName << " += " << std::to_string(elementSize) << ";\n";
+        out << offsetName << " += " << std::to_string(elementSize) << ";\n";
+    } else {
+        if (isReader) {
+            out << blobName
+                << ".copyTo"
+                << mElementType->getJavaSuffix()
+                << "Array("
+                << offsetName
+                << ", "
+                << fieldName
+                << indexString
+                << ", "
+                << mSizes.back()->javaValue()
+                << " /* size */);\n";
+        } else {
+            out << blobName
+                << ".put"
+                << mElementType->getJavaSuffix()
+                << "Array("
+                << offsetName
+                << ", "
+                << fieldName
+                << indexString
+                << ");\n";
+        }
 
-    for (size_t dim = 0; dim < mSizes.size(); ++dim) {
+        size_t elementAlign, elementSize;
+        mElementType->getAlignmentAndSize(&elementAlign, &elementSize);
+
+        out << offsetName
+            << " += "
+            << mSizes.back()->javaValue()
+            << " * "
+            << elementSize
+            << ";\n";
+    }
+
+    for (size_t dim = 0; dim < loopDimensions; ++dim) {
         out.unindent();
         out << "}\n";
     }
@@ -488,17 +558,14 @@
     out << "}\n";
 }
 
-status_t ArrayType::emitVtsTypeDeclarations(Formatter &out) const {
+void ArrayType::emitVtsTypeDeclarations(Formatter& out) const {
     out << "type: " << getVtsType() << "\n";
     out << "vector_size: " << mSizes[0]->value() << "\n";
     out << "vector_value: {\n";
     out.indent();
     // Simple array case.
     if (mSizes.size() == 1) {
-        status_t err = mElementType->emitVtsTypeDeclarations(out);
-        if (err != OK) {
-            return err;
-        }
+        mElementType->emitVtsTypeDeclarations(out);
     } else {  // Multi-dimension array case.
         for (size_t index = 1; index < mSizes.size(); index++) {
             out << "type: " << getVtsType() << "\n";
@@ -506,10 +573,7 @@
             out << "vector_value: {\n";
             out.indent();
             if (index == mSizes.size() - 1) {
-                status_t err = mElementType->emitVtsTypeDeclarations(out);
-                if (err != OK) {
-                    return err;
-                }
+                mElementType->emitVtsTypeDeclarations(out);
             }
         }
     }
@@ -517,15 +581,20 @@
         out.unindent();
         out << "}\n";
     }
-    return OK;
 }
 
-bool ArrayType::isJavaCompatible() const {
-    return mElementType->isJavaCompatible();
+bool ArrayType::deepIsJavaCompatible(std::unordered_set<const Type*>* visited) const {
+    if (!mElementType->isJavaCompatible(visited)) {
+        return false;
+    }
+    return Type::deepIsJavaCompatible(visited);
 }
 
-bool ArrayType::containsPointer() const {
-    return mElementType->containsPointer();
+bool ArrayType::deepContainsPointer(std::unordered_set<const Type*>* visited) const {
+    if (mElementType->containsPointer(visited)) {
+        return true;
+    }
+    return Type::deepContainsPointer(visited);
 }
 
 void ArrayType::getAlignmentAndSize(size_t *align, size_t *size) const {
diff --git a/ArrayType.h b/ArrayType.h
index 05ba783..2c13a33 100644
--- a/ArrayType.h
+++ b/ArrayType.h
@@ -18,6 +18,7 @@
 
 #define ARRAY_TYPE_H_
 
+#include "Reference.h"
 #include "Type.h"
 
 #include <vector>
@@ -27,22 +28,27 @@
 struct ConstantExpression;
 
 struct ArrayType : public Type {
-    // Extends existing array by adding another dimension.
-    ArrayType(ArrayType *srcArray, ConstantExpression *size);
-
-    ArrayType(Type *elementType, ConstantExpression *size);
+    ArrayType(const Reference<Type>& elementType, ConstantExpression* size, Scope* parent);
 
     bool isArray() const override;
-    bool canCheckEquality() const override;
+    bool deepCanCheckEquality(std::unordered_set<const Type*>* visited) const override;
 
-    Type *getElementType() const;
+    const Type* getElementType() const;
 
-    void prependDimension(ConstantExpression *size);
     void appendDimension(ConstantExpression *size);
     size_t countDimensions() const;
 
     std::string typeName() const override;
 
+    std::vector<const Reference<Type>*> getReferences() const override;
+
+    std::vector<const ConstantExpression*> getConstantExpressions() const override;
+
+    // Extends existing array by adding another dimension.
+    status_t resolveInheritance() override;
+
+    status_t validate() const override;
+
     std::string getCppType(StorageMode mode,
                            bool specifyNamespaces) const override;
 
@@ -103,7 +109,7 @@
             const std::string &name) const override;
 
     bool needsEmbeddedReadWrite() const override;
-    bool needsResolveReferences() const override;
+    bool deepNeedsResolveReferences(std::unordered_set<const Type*>* visited) const override;
     bool resultNeedsDeref() const override;
 
     void emitJavaReaderWriter(
@@ -124,16 +130,16 @@
             const std::string &offset,
             bool isReader) const override;
 
-    status_t emitVtsTypeDeclarations(Formatter &out) const override;
+    void emitVtsTypeDeclarations(Formatter& out) const override;
 
-    bool isJavaCompatible() const override;
-    bool containsPointer() const override;
+    bool deepIsJavaCompatible(std::unordered_set<const Type*>* visited) const override;
+    bool deepContainsPointer(std::unordered_set<const Type*>* visited) const override;
 
     void getAlignmentAndSize(size_t *align, size_t *size) const override;
 
-private:
-    Type *mElementType;
-    std::vector<ConstantExpression *> mSizes;
+   private:
+    Reference<Type> mElementType;
+    std::vector<ConstantExpression*> mSizes;
 
     size_t dimension() const;
 
diff --git a/CleanSpec.mk b/CleanSpec.mk
new file mode 100644
index 0000000..ebc0bad
--- /dev/null
+++ b/CleanSpec.mk
@@ -0,0 +1,47 @@
+# Copyright 2017 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.
+#
+
+# If you don't need to do a full clean build but would like to touch
+# a file or delete some intermediate files, add a clean step to the end
+# of the list.  These steps will only be run once, if they haven't been
+# run before.
+#
+# E.g.:
+#     $(call add-clean-step, touch -c external/sqlite/sqlite3.h)
+#     $(call add-clean-step, rm -rf $(PRODUCT_OUT)/obj/STATIC_LIBRARIES/libz_intermediates)
+#
+# Always use "touch -c" and "rm -f" or "rm -rf" to gracefully deal with
+# files that are missing or have been moved.
+#
+# Use $(PRODUCT_OUT) to get to the "out/target/product/blah/" directory.
+# Use $(OUT_DIR) to refer to the "out" directory.
+#
+# If you need to re-do something that's already mentioned, just copy
+# the command and add it to the bottom of the list.  E.g., if a change
+# that you made last week required touching a file and a change you
+# made today requires touching the same file, just copy the old
+# touch step and add it to the end of the list.
+#
+# ************************************************
+# NEWER CLEAN STEPS MUST BE AT THE END OF THE LIST
+# ************************************************
+
+# For example:
+#$(call add-clean-step, rm -rf $(OUT_DIR)/target/common/obj/APPS/AndroidTests_intermediates)
+#$(call add-clean-step, rm -rf $(OUT_DIR)/target/common/obj/JAVA_LIBRARIES/core_intermediates)
+#$(call add-clean-step, find $(OUT_DIR) -type f -name "IGTalkSession*" -print0 | xargs -0 rm -f)
+#$(call add-clean-step, rm -rf $(PRODUCT_OUT)/data/*)
+
+$(call add-clean-step, rm -rf $(SOONG_OUT_DIR)/.intermediates/hardware/interfaces/tests/extension)
diff --git a/CompoundType.cpp b/CompoundType.cpp
index b138d7b..87f0f14 100644
--- a/CompoundType.cpp
+++ b/CompoundType.cpp
@@ -18,61 +18,82 @@
 
 #include "ArrayType.h"
 #include "VectorType.h"
-#include <hidl-util/Formatter.h>
+
 #include <android-base/logging.h>
+#include <hidl-util/Formatter.h>
+#include <iostream>
+#include <unordered_set>
 
 namespace android {
 
-CompoundType::CompoundType(Style style, const char* localName, const Location& location,
-                           Scope* parent)
-    : Scope(localName, location, parent), mStyle(style), mFields(NULL) {}
+CompoundType::CompoundType(Style style, const char* localName, const FQName& fullName,
+                           const Location& location, Scope* parent)
+    : Scope(localName, fullName, location, parent), mStyle(style), mFields(NULL) {}
 
 CompoundType::Style CompoundType::style() const {
     return mStyle;
 }
 
-bool CompoundType::setFields(
-        std::vector<CompoundField *> *fields, std::string *errorMsg) {
+void CompoundType::setFields(std::vector<NamedReference<Type>*>* fields) {
     mFields = fields;
+}
 
-    for (const auto &field : *fields) {
-        const Type &type = field->type();
+std::vector<const Reference<Type>*> CompoundType::getReferences() const {
+    std::vector<const Reference<Type>*> ret;
+    ret.insert(ret.begin(), mFields->begin(), mFields->end());
+    return ret;
+}
 
-        if (type.isBinder()
-                || (type.isVector()
-                    && static_cast<const VectorType *>(
-                        &type)->isVectorOfBinders())) {
-            *errorMsg =
-                "Structs/Unions must not contain references to interfaces.";
+status_t CompoundType::validate() const {
+    for (const auto* field : *mFields) {
+        const Type& type = field->type();
 
-            return false;
+        if ((type.isVector() && static_cast<const VectorType*>(&type)->isVectorOfBinders())) {
+            std::cerr << "ERROR: Struct/Union must not contain references to interfaces at "
+                      << field->location() << "\n";
+            return UNKNOWN_ERROR;
         }
 
         if (mStyle == STYLE_UNION) {
             if (type.needsEmbeddedReadWrite()) {
-                // Can't have those in a union.
-
-                *errorMsg =
-                    "Unions must not contain any types that need fixup.";
-
-                return false;
+                std::cerr << "ERROR: Union must not contain any types that need fixup at "
+                          << field->location() << "\n";
+                return UNKNOWN_ERROR;
             }
         }
     }
 
-    return true;
+    status_t err = validateUniqueNames();
+    if (err != OK) return err;
+
+    return Scope::validate();
+}
+
+status_t CompoundType::validateUniqueNames() const {
+    std::unordered_set<std::string> names;
+
+    for (const auto* field : *mFields) {
+        if (names.find(field->name()) != names.end()) {
+            std::cerr << "ERROR: Redefinition of field '" << field->name() << "' at "
+                      << field->location() << "\n";
+            return UNKNOWN_ERROR;
+        }
+        names.insert(field->name());
+    }
+
+    return OK;
 }
 
 bool CompoundType::isCompoundType() const {
     return true;
 }
 
-bool CompoundType::canCheckEquality() const {
+bool CompoundType::deepCanCheckEquality(std::unordered_set<const Type*>* visited) const {
     if (mStyle == STYLE_UNION) {
         return false;
     }
-    for (const auto &field : *mFields) {
-        if (!field->type().canCheckEquality()) {
+    for (const auto* field : *mFields) {
+        if (!field->get()->canCheckEquality(visited)) {
             return false;
         }
     }
@@ -104,7 +125,7 @@
             return "const " + base + "&";
 
         case StorageMode_Result:
-            return "const " + base + "*";
+            return base + (containsInterface()?"":"*");
     }
 }
 
@@ -126,6 +147,22 @@
     CHECK(!"Should not be here");
 }
 
+bool CompoundType::containsInterface() const {
+    for (const auto& field : *mFields) {
+        if (field->type().isCompoundType()) {
+            const Type& t = field->type();
+            const CompoundType* ct = static_cast<const CompoundType*>(&t);
+            if (ct->containsInterface()) {
+                return true;
+            }
+        }
+        if (field->type().isInterface()) {
+            return true;
+        }
+    }
+    return false;
+}
+
 void CompoundType::emitReaderWriter(
         Formatter &out,
         const std::string &name,
@@ -133,57 +170,47 @@
         bool parcelObjIsPointer,
         bool isReader,
         ErrorMode mode) const {
-    const std::string parentName = "_hidl_" + name + "_parent";
-
-    out << "size_t " << parentName << ";\n\n";
 
     const std::string parcelObjDeref =
         parcelObj + (parcelObjIsPointer ? "->" : ".");
 
-    if (isReader) {
-        out << "_hidl_err = "
-            << parcelObjDeref
-            << "readBuffer("
-            << "sizeof(*"
-            << name
-            << "), &"
-            << parentName
-            << ", "
-            << " reinterpret_cast<const void **>("
-            << "&" << name
-            << "));\n";
-
-        handleError(out, mode);
+    if(containsInterface()){
+        for (const auto& field : *mFields) {
+            field->type().emitReaderWriter(out, name + "." + field->name(),
+                                               parcelObj, parcelObjIsPointer, isReader, mode);
+        }
     } else {
-        out << "_hidl_err = "
-            << parcelObjDeref
-            << "writeBuffer(&"
-            << name
-            << ", sizeof("
-            << name
-            << "), &"
-            << parentName
-            << ");\n";
+        const std::string parentName = "_hidl_" + name + "_parent";
 
-        handleError(out, mode);
+        out << "size_t " << parentName << ";\n\n";
+
+        if (isReader) {
+            out << "_hidl_err = " << parcelObjDeref << "readBuffer("
+                << "sizeof(*" << name << "), &" << parentName << ", "
+                << " const_cast<const void**>(reinterpret_cast<void **>("
+                << "&" << name << ")));\n";
+            handleError(out, mode);
+        } else {
+            out << "_hidl_err = "
+                << parcelObjDeref
+                << "writeBuffer(&"
+                << name
+                << ", sizeof("
+                << name
+                << "), &"
+                << parentName
+                << ");\n";
+            handleError(out, mode);
+        }
+        if (mStyle != STYLE_STRUCT) {
+            return;
+        }
+        if (needsEmbeddedReadWrite()) {
+            emitReaderWriterEmbedded(out, 0 /* depth */, name, name, /* sanitizedName */
+                                     isReader /* nameIsPointer */, parcelObj, parcelObjIsPointer,
+                                     isReader, mode, parentName, "0 /* parentOffset */");
+        }
     }
-
-    if (mStyle != STYLE_STRUCT || !needsEmbeddedReadWrite()) {
-        return;
-    }
-
-    emitReaderWriterEmbedded(
-            out,
-            0 /* depth */,
-            name,
-            name, /* sanitizedName */
-            isReader /* nameIsPointer */,
-            parcelObj,
-            parcelObjIsPointer,
-            isReader,
-            mode,
-            parentName,
-            "0 /* parentOffset */");
 }
 
 void CompoundType::emitReaderWriterEmbedded(
@@ -347,7 +374,7 @@
     handleError(out, mode);
 }
 
-status_t CompoundType::emitTypeDeclarations(Formatter &out) const {
+void CompoundType::emitTypeDeclarations(Formatter& out) const {
     out << ((mStyle == STYLE_STRUCT) ? "struct" : "union")
         << " "
         << localName()
@@ -359,6 +386,7 @@
 
     if (containsPointer()) {
         for (const auto &field : *mFields) {
+            field->emitDocComment(out);
             out << field->type().getCppStackType()
                 << " "
                 << field->name()
@@ -368,7 +396,7 @@
         out.unindent();
         out << "};\n\n";
 
-        return OK;
+        return;
     }
 
     for (int pass = 0; pass < 2; ++pass) {
@@ -424,32 +452,62 @@
         << ") == "
         << structAlign
         << ", \"wrong alignment\");\n\n";
-
-    return OK;
 }
 
+void CompoundType::emitTypeForwardDeclaration(Formatter& out) const {
+    out << ((mStyle == STYLE_STRUCT) ? "struct" : "union") << " " << localName() << ";\n";
+}
 
-status_t CompoundType::emitGlobalTypeDeclarations(Formatter &out) const {
-    Scope::emitGlobalTypeDeclarations(out);
+void CompoundType::emitPackageTypeDeclarations(Formatter& out) const {
+    Scope::emitPackageTypeDeclarations(out);
 
-    out << "std::string toString("
+    out << "static inline std::string toString("
         << getCppArgumentType()
-        << ");\n\n";
+        << (mFields->empty() ? "" : " o")
+        << ") ";
+
+    out.block([&] {
+        // include toString for scalar types
+        out << "using ::android::hardware::toString;\n"
+            << "std::string os;\n";
+        out << "os += \"{\";\n";
+
+        for (const NamedReference<Type>* field : *mFields) {
+            out << "os += \"";
+            if (field != *(mFields->begin())) {
+                out << ", ";
+            }
+            out << "." << field->name() << " = \";\n";
+            field->type().emitDump(out, "os", "o." + field->name());
+        }
+
+        out << "os += \"}\"; return os;\n";
+    }).endl().endl();
 
     if (canCheckEquality()) {
-        out << "bool operator==("
-            << getCppArgumentType() << ", " << getCppArgumentType() << ");\n\n";
+        out << "static inline bool operator==("
+            << getCppArgumentType() << " " << (mFields->empty() ? "/* lhs */" : "lhs") << ", "
+            << getCppArgumentType() << " " << (mFields->empty() ? "/* rhs */" : "rhs") << ") ";
+        out.block([&] {
+            for (const auto &field : *mFields) {
+                out.sIf("lhs." + field->name() + " != rhs." + field->name(), [&] {
+                    out << "return false;\n";
+                }).endl();
+            }
+            out << "return true;\n";
+        }).endl().endl();
 
-        out << "bool operator!=("
-            << getCppArgumentType() << ", " << getCppArgumentType() << ");\n\n";
+        out << "static inline bool operator!=("
+            << getCppArgumentType() << " lhs," << getCppArgumentType() << " rhs)";
+        out.block([&] {
+            out << "return !(lhs == rhs);\n";
+        }).endl().endl();
     } else {
         out << "// operator== and operator!= are not generated for " << localName() << "\n\n";
     }
-
-    return OK;
 }
 
-status_t CompoundType::emitGlobalHwDeclarations(Formatter &out) const  {
+void CompoundType::emitPackageHwDeclarations(Formatter& out) const {
     if (needsEmbeddedReadWrite()) {
         out << "::android::status_t readEmbeddedFromParcel(\n";
 
@@ -488,18 +546,11 @@
             << "size_t parentHandle, size_t parentOffset);\n\n";
         out.unindent(2);
     }
-
-    return OK;
 }
 
-status_t CompoundType::emitTypeDefinitions(
-        Formatter &out, const std::string prefix) const {
+void CompoundType::emitTypeDefinitions(Formatter& out, const std::string& prefix) const {
     std::string space = prefix.empty() ? "" : (prefix + "::");
-    status_t err = Scope::emitTypeDefinitions(out, space + localName());
-
-    if (err != OK) {
-        return err;
-    }
+    Scope::emitTypeDefinitions(out, space + localName());
 
     if (needsEmbeddedReadWrite()) {
         emitStructReaderWriter(out, prefix, true /* isReader */);
@@ -510,57 +561,9 @@
         emitResolveReferenceDef(out, prefix, true /* isReader */);
         emitResolveReferenceDef(out, prefix, false /* isReader */);
     }
-
-    out << "std::string toString("
-        << getCppArgumentType()
-        << (mFields->empty() ? "" : " o")
-        << ") ";
-
-    out.block([&] {
-        // include toString for scalar types
-        out << "using ::android::hardware::toString;\n"
-            << "std::string os;\n";
-        out << "os += \"{\";\n";
-
-        for (const CompoundField *field : *mFields) {
-            out << "os += \"";
-            if (field != *(mFields->begin())) {
-                out << ", ";
-            }
-            out << "." << field->name() << " = \";\n";
-            field->type().emitDump(out, "os", "o." + field->name());
-        }
-
-        out << "os += \"}\"; return os;\n";
-    }).endl().endl();
-
-    if (canCheckEquality()) {
-        out << "bool operator==("
-            << getCppArgumentType() << " " << (mFields->empty() ? "/* lhs */" : "lhs") << ", "
-            << getCppArgumentType() << " " << (mFields->empty() ? "/* rhs */" : "rhs") << ") ";
-        out.block([&] {
-            for (const auto &field : *mFields) {
-                out.sIf("lhs." + field->name() + " != rhs." + field->name(), [&] {
-                    out << "return false;\n";
-                }).endl();
-            }
-            out << "return true;\n";
-        }).endl().endl();
-
-        out << "bool operator!=("
-            << getCppArgumentType() << " lhs," << getCppArgumentType() << " rhs)";
-        out.block([&] {
-            out << "return !(lhs == rhs);\n";
-        }).endl().endl();
-    } else {
-        out << "// operator== and operator!= are not generated for " << localName() << "\n";
-    }
-
-    return OK;
 }
 
-status_t CompoundType::emitJavaTypeDeclarations(
-        Formatter &out, bool atTopLevel) const {
+void CompoundType::emitJavaTypeDeclarations(Formatter& out, bool atTopLevel) const {
     out << "public final ";
 
     if (!atTopLevel) {
@@ -575,7 +578,9 @@
 
     Scope::emitJavaTypeDeclarations(out, false /* atTopLevel */);
 
-    for (const auto &field : *mFields) {
+    for (const auto& field : *mFields) {
+        field->emitDocComment(out);
+
         out << "public ";
 
         field->type().emitJavaFieldInitializer(out, field->name());
@@ -651,9 +656,16 @@
 
     out << "public final void readFromParcel(android.os.HwParcel parcel) {\n";
     out.indent();
-    out << "android.os.HwBlob blob = parcel.readBuffer(";
-    out << structSize << "/* size */);\n";
-    out << "readEmbeddedFromParcel(parcel, blob, 0 /* parentOffset */);\n";
+    if (containsInterface()) {
+        for (const auto& field : *mFields) {
+            out << field->name() << " = ";
+            field->type().emitJavaReaderWriter(out, "parcel", field->name(), true);
+        }
+    } else {
+        out << "android.os.HwBlob blob = parcel.readBuffer(";
+        out << structSize << "/* size */);\n";
+        out << "readEmbeddedFromParcel(parcel, blob, 0 /* parentOffset */);\n";
+    }
     out.unindent();
     out << "}\n\n";
 
@@ -662,77 +674,75 @@
     size_t vecAlign, vecSize;
     VectorType::getAlignmentAndSizeStatic(&vecAlign, &vecSize);
 
-    out << "public static final java.util.ArrayList<"
-        << localName()
+    out << "public static final java.util.ArrayList<" << localName()
         << "> readVectorFromParcel(android.os.HwParcel parcel) {\n";
     out.indent();
 
-    out << "java.util.ArrayList<"
-        << localName()
-        << "> _hidl_vec = new java.util.ArrayList();\n";
+    out << "java.util.ArrayList<" << localName() << "> _hidl_vec = new java.util.ArrayList();\n";
 
-    out << "android.os.HwBlob _hidl_blob = parcel.readBuffer(";
-    out << vecSize << " /* sizeof hidl_vec<T> */);\n\n";
+    if (containsInterface()) {
+        out << "int size = parcel.readInt32();\n";
+        out << "for(int i = 0 ; i < size; i ++) {\n";
+        out.indent();
+        out << fullJavaName() << " tmp = ";
+        emitJavaReaderWriter(out, "parcel", "tmp", true);
+        out << "_hidl_vec.add(tmp);\n";
+        out.unindent();
+        out << "}\n";
+    } else {
+        out << "android.os.HwBlob _hidl_blob = parcel.readBuffer(";
+        out << vecSize << " /* sizeof hidl_vec<T> */);\n\n";
 
-    VectorType::EmitJavaFieldReaderWriterForElementType(
-            out,
-            0 /* depth */,
-            this,
-            "parcel",
-            "_hidl_blob",
-            "_hidl_vec",
-            "0",
-            true /* isReader */);
-
-    out << "\nreturn _hidl_vec;\n";
-
-    out.unindent();
-    out << "}\n\n";
-
-    ////////////////////////////////////////////////////////////////////////////
-
-    out << "public final void readEmbeddedFromParcel(\n";
-    out.indent(2);
-    out << "android.os.HwParcel parcel, android.os.HwBlob _hidl_blob, long _hidl_offset) {\n";
-    out.unindent();
-
-    size_t offset = 0;
-    for (const auto &field : *mFields) {
-        size_t fieldAlign, fieldSize;
-        field->type().getAlignmentAndSize(&fieldAlign, &fieldSize);
-
-        size_t pad = offset % fieldAlign;
-        if (pad > 0) {
-            offset += fieldAlign - pad;
-        }
-
-        field->type().emitJavaFieldReaderWriter(
-                out,
-                0 /* depth */,
-                "parcel",
-                "_hidl_blob",
-                field->name(),
-                "_hidl_offset + " + std::to_string(offset),
-                true /* isReader */);
-
-        offset += fieldSize;
+        VectorType::EmitJavaFieldReaderWriterForElementType(out, 0 /* depth */, this, "parcel",
+                                                            "_hidl_blob", "_hidl_vec", "0",
+                                                            true /* isReader */);
     }
-
+    out << "\nreturn _hidl_vec;\n";
     out.unindent();
     out << "}\n\n";
+    ////////////////////////////////////////////////////////////////////////////
+    if (containsInterface()) {
+        out << "// readEmbeddedFromParcel is not generated()\n";
+    } else {
+        out << "public final void readEmbeddedFromParcel(\n";
+        out.indent(2);
+        out << "android.os.HwParcel parcel, android.os.HwBlob _hidl_blob, long _hidl_offset) {\n";
+        out.unindent();
+        size_t offset = 0;
+        for (const auto& field : *mFields) {
+            size_t fieldAlign, fieldSize;
+            field->type().getAlignmentAndSize(&fieldAlign, &fieldSize);
+
+            size_t pad = offset % fieldAlign;
+            if (pad > 0) {
+                offset += fieldAlign - pad;
+            }
+
+            field->type().emitJavaFieldReaderWriter(
+                out, 0 /* depth */, "parcel", "_hidl_blob", field->name(),
+                "_hidl_offset + " + std::to_string(offset), true /* isReader */);
+            offset += fieldSize;
+        }
+        out.unindent();
+        out << "}\n\n";
+    }
 
     ////////////////////////////////////////////////////////////////////////////
 
     out << "public final void writeToParcel(android.os.HwParcel parcel) {\n";
     out.indent();
 
-    out << "android.os.HwBlob _hidl_blob = new android.os.HwBlob("
-        << structSize
-        << " /* size */);\n";
+    if (containsInterface()) {
+        for (const auto& field : *mFields) {
+            field->type().emitJavaReaderWriter(out, "parcel", field->name(), false);
+        }
+    } else {
+        out << "android.os.HwBlob _hidl_blob = new android.os.HwBlob(" << structSize
+            << " /* size */);\n";
 
-    out << "writeEmbeddedToBlob(_hidl_blob, 0 /* parentOffset */);\n"
-        << "parcel.writeBuffer(_hidl_blob);\n";
-
+        out << "writeEmbeddedToBlob(_hidl_blob, 0 /* parentOffset */);\n"
+            << "parcel.writeBuffer(_hidl_blob);\n";
+    }
     out.unindent();
     out << "}\n\n";
 
@@ -740,65 +750,56 @@
 
     out << "public static final void writeVectorToParcel(\n";
     out.indent(2);
-    out << "android.os.HwParcel parcel, java.util.ArrayList<"
-        << localName()
-        << "> _hidl_vec) {\n";
+    out << "android.os.HwParcel parcel, java.util.ArrayList<" << localName() << "> _hidl_vec) {\n";
     out.unindent();
 
-    out << "android.os.HwBlob _hidl_blob = new android.os.HwBlob("
-        << vecSize << " /* sizeof(hidl_vec<T>) */);\n";
+    if (containsInterface()) {
+        out << "parcel.writeInt32(_hidl_vec.size());\n";
+        out << "for(" << fullJavaName() << " tmp: _hidl_vec)\n";
+        out.indent();
+        emitJavaReaderWriter(out, "parcel", "tmp", false);
+        out.unindent();
+    } else {
+        out << "android.os.HwBlob _hidl_blob = new android.os.HwBlob(" << vecSize
+            << " /* sizeof(hidl_vec<T>) */);\n";
 
-    VectorType::EmitJavaFieldReaderWriterForElementType(
-            out,
-            0 /* depth */,
-            this,
-            "parcel",
-            "_hidl_blob",
-            "_hidl_vec",
-            "0",
-            false /* isReader */);
+        VectorType::EmitJavaFieldReaderWriterForElementType(out, 0 /* depth */, this, "parcel",
+                                                            "_hidl_blob", "_hidl_vec", "0",
+                                                            false /* isReader */);
 
-    out << "\nparcel.writeBuffer(_hidl_blob);\n";
-
+        out << "\nparcel.writeBuffer(_hidl_blob);\n";
+    }
     out.unindent();
     out << "}\n\n";
-
     ////////////////////////////////////////////////////////////////////////////
 
-    out << "public final void writeEmbeddedToBlob(\n";
-    out.indent(2);
-    out << "android.os.HwBlob _hidl_blob, long _hidl_offset) {\n";
-    out.unindent();
-
-    offset = 0;
-    for (const auto &field : *mFields) {
-        size_t fieldAlign, fieldSize;
-        field->type().getAlignmentAndSize(&fieldAlign, &fieldSize);
-
-        size_t pad = offset % fieldAlign;
-        if (pad > 0) {
-            offset += fieldAlign - pad;
+    if (containsInterface()) {
+        out << "// writeEmbeddedFromParcel() is not generated\n";
+    } else {
+        out << "public final void writeEmbeddedToBlob(\n";
+        out.indent(2);
+        out << "android.os.HwBlob _hidl_blob, long _hidl_offset) {\n";
+        out.unindent();
+        size_t offset = 0;
+        for (const auto& field : *mFields) {
+            size_t fieldAlign, fieldSize;
+            field->type().getAlignmentAndSize(&fieldAlign, &fieldSize);
+            size_t pad = offset % fieldAlign;
+            if (pad > 0) {
+                offset += fieldAlign - pad;
+            }
+            field->type().emitJavaFieldReaderWriter(
+                out, 0 /* depth */, "parcel", "_hidl_blob", field->name(),
+                "_hidl_offset + " + std::to_string(offset), false /* isReader */);
+            offset += fieldSize;
         }
 
-        field->type().emitJavaFieldReaderWriter(
-                out,
-                0 /* depth */,
-                "parcel",
-                "_hidl_blob",
-                field->name(),
-                "_hidl_offset + " + std::to_string(offset),
-                false /* isReader */);
-
-        offset += fieldSize;
+        out.unindent();
+        out << "}\n";
     }
 
     out.unindent();
-    out << "}\n";
-
-    out.unindent();
     out << "};\n\n";
-
-    return OK;
 }
 
 void CompoundType::emitStructReaderWriter(
@@ -872,8 +873,8 @@
     out << "}\n\n";
 }
 
-void CompoundType::emitResolveReferenceDef(
-        Formatter &out, const std::string prefix, bool isReader) const {
+void CompoundType::emitResolveReferenceDef(Formatter& out, const std::string& prefix,
+                                           bool isReader) const {
     out << "::android::status_t ";
     const std::string space(prefix.empty() ? "" : (prefix + "::"));
 
@@ -962,25 +963,25 @@
     return false;
 }
 
-bool CompoundType::needsResolveReferences() const {
+bool CompoundType::deepNeedsResolveReferences(std::unordered_set<const Type*>* visited) const {
     if (mStyle != STYLE_STRUCT) {
         return false;
     }
 
     for (const auto &field : *mFields) {
-        if (field->type().needsResolveReferences()) {
+        if (field->type().needsResolveReferences(visited)) {
             return true;
         }
     }
 
-    return false;
+    return Scope::deepNeedsResolveReferences(visited);
 }
 
 bool CompoundType::resultNeedsDeref() const {
-    return true;
+    return !containsInterface() ;
 }
 
-status_t CompoundType::emitVtsTypeDeclarations(Formatter &out) const {
+void CompoundType::emitVtsTypeDeclarations(Formatter& out) const {
     out << "name: \"" << fullName() << "\"\n";
     out << "type: " << getVtsType() << "\n";
 
@@ -999,10 +1000,7 @@
             }
         }
         out.indent();
-        status_t status(type->emitVtsTypeDeclarations(out));
-        if (status != OK) {
-            return status;
-        }
+        type->emitVtsTypeDeclarations(out);
         out.unindent();
         out << "}\n";
     }
@@ -1023,49 +1021,39 @@
         }
         out.indent();
         out << "name: \"" << field->name() << "\"\n";
-        status_t status = field->type().emitVtsAttributeType(out);
-        if (status != OK) {
-            return status;
-        }
+        field->type().emitVtsAttributeType(out);
         out.unindent();
         out << "}\n";
     }
-
-    return OK;
 }
 
-status_t CompoundType::emitVtsAttributeType(Formatter &out) const {
+void CompoundType::emitVtsAttributeType(Formatter& out) const {
     out << "type: " << getVtsType() << "\n";
     out << "predefined_type: \"" << fullName() << "\"\n";
-    return OK;
 }
 
-bool CompoundType::isJavaCompatible() const {
-    if (mStyle != STYLE_STRUCT || !Scope::isJavaCompatible()) {
+bool CompoundType::deepIsJavaCompatible(std::unordered_set<const Type*>* visited) const {
+    if (mStyle != STYLE_STRUCT) {
         return false;
     }
 
-    for (const auto &field : *mFields) {
-        if (!field->type().isJavaCompatible()) {
+    for (const auto* field : *mFields) {
+        if (!field->get()->isJavaCompatible(visited)) {
             return false;
         }
     }
 
-    return true;
+    return Scope::deepIsJavaCompatible(visited);
 }
 
-bool CompoundType::containsPointer() const {
-    if (Scope::containsPointer()) {
-        return true;
-    }
-
-    for (const auto &field : *mFields) {
-        if (field->type().containsPointer()) {
+bool CompoundType::deepContainsPointer(std::unordered_set<const Type*>* visited) const {
+    for (const auto* field : *mFields) {
+        if (field->get()->containsPointer(visited)) {
             return true;
         }
     }
 
-    return false;
+    return Scope::deepContainsPointer(visited);
 }
 
 void CompoundType::getAlignmentAndSize(size_t *align, size_t *size) const {
@@ -1113,20 +1101,5 @@
     }
 }
 
-////////////////////////////////////////////////////////////////////////////////
-
-CompoundField::CompoundField(const char *name, Type *type)
-    : mName(name),
-      mType(type) {
-}
-
-std::string CompoundField::name() const {
-    return mName;
-}
-
-const Type &CompoundField::type() const {
-    return *mType;
-}
-
 }  // namespace android
 
diff --git a/CompoundType.h b/CompoundType.h
index 4917dec..3ef5f02 100644
--- a/CompoundType.h
+++ b/CompoundType.h
@@ -18,32 +18,37 @@
 
 #define COMPOUND_TYPE_H_
 
+#include "Reference.h"
 #include "Scope.h"
 
 #include <vector>
 
 namespace android {
 
-struct CompoundField;
-
 struct CompoundType : public Scope {
     enum Style {
         STYLE_STRUCT,
         STYLE_UNION,
     };
 
-    CompoundType(Style style, const char* localName, const Location& location, Scope* parent);
+    CompoundType(Style style, const char* localName, const FQName& fullName,
+                 const Location& location, Scope* parent);
 
     Style style() const;
 
-    bool setFields(std::vector<CompoundField *> *fields, std::string *errorMsg);
+    void setFields(std::vector<NamedReference<Type>*>* fields);
 
     bool isCompoundType() const override;
 
-    bool canCheckEquality() const override;
+    bool deepCanCheckEquality(std::unordered_set<const Type*>* visited) const override;
 
     std::string typeName() const override;
 
+    std::vector<const Reference<Type>*> getReferences() const override;
+
+    status_t validate() const override;
+    status_t validateUniqueNames() const;
+
     std::string getCppType(StorageMode mode,
                            bool specifyNamespaces) const override;
 
@@ -112,53 +117,39 @@
             const std::string &offset,
             bool isReader) const override;
 
-    status_t emitTypeDeclarations(Formatter &out) const override;
-    status_t emitGlobalTypeDeclarations(Formatter &out) const override;
-    status_t emitGlobalHwDeclarations(Formatter &out) const override;
+    void emitTypeDeclarations(Formatter& out) const override;
+    void emitTypeForwardDeclaration(Formatter& out) const override;
+    void emitPackageTypeDeclarations(Formatter& out) const override;
+    void emitPackageHwDeclarations(Formatter& out) const override;
 
-    status_t emitTypeDefinitions(
-            Formatter &out, const std::string prefix) const override;
+    void emitTypeDefinitions(Formatter& out, const std::string& prefix) const override;
 
-    status_t emitJavaTypeDeclarations(
-            Formatter &out, bool atTopLevel) const override;
+    void emitJavaTypeDeclarations(Formatter& out, bool atTopLevel) const override;
 
     bool needsEmbeddedReadWrite() const override;
-    bool needsResolveReferences() const override;
+    bool deepNeedsResolveReferences(std::unordered_set<const Type*>* visited) const override;
     bool resultNeedsDeref() const override;
 
-    status_t emitVtsTypeDeclarations(Formatter &out) const override;
-    status_t emitVtsAttributeType(Formatter &out) const override;
+    void emitVtsTypeDeclarations(Formatter& out) const override;
+    void emitVtsAttributeType(Formatter& out) const override;
 
-    bool isJavaCompatible() const override;
-    bool containsPointer() const override;
+    bool deepIsJavaCompatible(std::unordered_set<const Type*>* visited) const override;
+    bool deepContainsPointer(std::unordered_set<const Type*>* visited) const override;
 
     void getAlignmentAndSize(size_t *align, size_t *size) const;
 
+    bool containsInterface() const;
 private:
     Style mStyle;
-    std::vector<CompoundField *> *mFields;
+    std::vector<NamedReference<Type>*>* mFields;
 
     void emitStructReaderWriter(
             Formatter &out, const std::string &prefix, bool isReader) const;
-    void emitResolveReferenceDef(
-        Formatter &out, const std::string prefix, bool isReader) const;
+    void emitResolveReferenceDef(Formatter& out, const std::string& prefix, bool isReader) const;
 
     DISALLOW_COPY_AND_ASSIGN(CompoundType);
 };
 
-struct CompoundField {
-    CompoundField(const char *name, Type *type);
-
-    std::string name() const;
-    const Type &type() const;
-
-private:
-    std::string mName;
-    Type *mType;
-
-    DISALLOW_COPY_AND_ASSIGN(CompoundField);
-};
-
 }  // namespace android
 
 #endif  // COMPOUND_TYPE_H_
diff --git a/ConstantExpression.cpp b/ConstantExpression.cpp
index eba28e1..8a2b875 100644
--- a/ConstantExpression.cpp
+++ b/ConstantExpression.cpp
@@ -16,21 +16,23 @@
 
 #include "ConstantExpression.h"
 
-#include <stdio.h>
-#include <string>
-#include <android-base/parseint.h>
 #include <android-base/logging.h>
+#include <android-base/parseint.h>
+#include <stdio.h>
+#include <algorithm>
+#include <iostream>
 #include <sstream>
+#include <string>
 
 #include "EnumType.h"
+#include "Scope.h"  // LocalIdentifier
 
 // The macros are really nasty here. Consider removing
 // as many macros as possible.
 
-#define STREQ(__x__, __y__) (strcmp((__x__), (__y__)) == 0)
-#define OPEQ(__y__) STREQ(op, __y__)
-#define COMPUTE_UNARY(__op__)  if(OPEQ(#__op__)) return __op__ val;
-#define COMPUTE_BINARY(__op__) if(OPEQ(#__op__)) return lval __op__ rval;
+#define OPEQ(__y__) (std::string(mOp) == std::string(__y__))
+#define COMPUTE_UNARY(__op__)  if (op == std::string(#__op__)) return __op__ val;
+#define COMPUTE_BINARY(__op__) if (op == std::string(#__op__)) return lval __op__ rval;
 #define OP_IS_BIN_ARITHMETIC  (OPEQ("+") || OPEQ("-") || OPEQ("*") || OPEQ("/") || OPEQ("%"))
 #define OP_IS_BIN_BITFLIP     (OPEQ("|") || OPEQ("^") || OPEQ("&"))
 #define OP_IS_BIN_COMP        (OPEQ("<") || OPEQ(">") || OPEQ("<=") || OPEQ(">=") || OPEQ("==") || OPEQ("!="))
@@ -39,6 +41,7 @@
 #define SK(__x__) ScalarType::Kind::KIND_##__x__
 #define SHOULD_NOT_REACH() CHECK(false) << __LINE__ << ": should not reach here: "
 
+// NOLINT to suppress missing parentheses warnings about __def__.
 #define SWITCH_KIND(__cond__, __action__, __def__)           \
         switch(__cond__) {                                        \
             case SK(BOOL): __action__(bool)                         \
@@ -50,13 +53,13 @@
             case SK(INT32): __action__(int32_t)                     \
             case SK(UINT64): __action__(uint64_t)                   \
             case SK(INT64): __action__(int64_t)                     \
-            default: __def__                                        \
-        }                                                         \
+            default: __def__                        /* NOLINT */    \
+        }
 
 namespace android {
 
 static inline bool isSupported(ScalarType::Kind kind) {
-    return SK(BOOL) == kind || ScalarType(kind).isValidEnumStorageType();
+    return SK(BOOL) == kind || ScalarType(kind, nullptr /* parent */).isValidEnumStorageType();
 }
 
 /* See docs at the end for details on integral promotion. */
@@ -84,8 +87,7 @@
 
     // Although there is such rule to return "the unsigned counterpart of
     // the signed operand", it should not reach here in our HIDL grammar.
-    LOG(FATAL) << "Could not do usual arithmetic conversion for type "
-               << lft << "and" << rgt;
+    CHECK(false) << "Could not do usual arithmetic conversion for type " << lft << "and" << rgt;
     switch(signedRank) {
         case SK(INT8):  return SK(UINT8);
         case SK(INT16): return SK(UINT16);
@@ -96,7 +98,7 @@
 }
 
 template <class T>
-T handleUnary(const char *op, T val) {
+T handleUnary(const std::string& op, T val) {
     COMPUTE_UNARY(+)
     COMPUTE_UNARY(-)
     COMPUTE_UNARY(!)
@@ -107,7 +109,7 @@
 }
 
 template <class T>
-T handleBinaryCommon(T lval, const char *op, T rval) {
+T handleBinaryCommon(T lval, const std::string& op, T rval) {
     COMPUTE_BINARY(+)
     COMPUTE_BINARY(-)
     COMPUTE_BINARY(*)
@@ -130,173 +132,182 @@
 }
 
 template <class T>
-T handleShift(T lval, const char *op, int64_t rval) {
+T handleShift(T lval, const std::string& op, int64_t rval) {
     // just cast rval to int64_t and it should fit.
     COMPUTE_BINARY(>>)
     COMPUTE_BINARY(<<)
     // Should not reach here.
-    SHOULD_NOT_REACH() << "Could not handleShift for"
+    SHOULD_NOT_REACH() << "Could not handleShift for "
                        << lval << " " << op << " " << rval;
     return static_cast<T>(0xdeadbeef);
 }
 
-bool handleLogical(bool lval, const char *op, bool rval) {
+bool handleLogical(bool lval, const std::string& op, bool rval) {
     COMPUTE_BINARY(||);
     COMPUTE_BINARY(&&);
     // Should not reach here.
-    SHOULD_NOT_REACH() << "Could not handleLogical for"
+    SHOULD_NOT_REACH() << "Could not handleLogical for "
                        << lval << " " << op << " " << rval;
     return false;
 }
 
-ConstantExpression::ConstantExpression() {
+std::unique_ptr<ConstantExpression> ConstantExpression::Zero(ScalarType::Kind kind) {
+    return ValueOf(kind, 0);
 }
 
-ConstantExpression ConstantExpression::Zero(ScalarType::Kind kind) {
-    ConstantExpression ce = ValueOf(kind, 0);
-    ce.mExpr = "0";
-    return ce;
+std::unique_ptr<ConstantExpression> ConstantExpression::One(ScalarType::Kind kind) {
+    return ValueOf(kind, 1);
 }
 
-ConstantExpression ConstantExpression::One(ScalarType::Kind kind) {
-    ConstantExpression ce = ValueOf(kind, 1);
-    ce.mExpr = "1";
-    return ce;
+std::unique_ptr<ConstantExpression> ConstantExpression::ValueOf(ScalarType::Kind kind,
+                                                                uint64_t value) {
+    return std::make_unique<LiteralConstantExpression>(kind, value);
 }
 
-ConstantExpression ConstantExpression::ValueOf(ScalarType::Kind kind, uint64_t value) {
-    ConstantExpression ce;
+bool ConstantExpression::isEvaluated() const {
+    return mIsEvaluated;
+}
+
+LiteralConstantExpression::LiteralConstantExpression(
+    ScalarType::Kind kind, uint64_t value, const std::string& expr) {
+
+    CHECK(!expr.empty());
     CHECK(isSupported(kind));
-
-    ce.mExpr = "";
-    ce.mType = kConstExprLiteral;
-    ce.mValueKind = kind;
-    ce.mValue = value;
-    ce.mTrivialDescription = true;
-    return ce;
-}
-ConstantExpression::ConstantExpression(const ConstantExpression& other) {
-    *this = other;
-}
-
-/* Copy constructor, with the expr overriden and treated non-trivial */
-ConstantExpression::ConstantExpression(const ConstantExpression& other, std::string expr) {
-    *this = other;
+    mTrivialDescription = true;
     mExpr = expr;
-    mTrivialDescription = false;
+    mValueKind = kind;
+    mValue = value;
+    mIsEvaluated = true;
 }
 
-ConstantExpression& ConstantExpression::operator=(const ConstantExpression& other) {
-    mType = other.mType;
-    mValueKind = other.mValueKind;
-    mValue = other.mValue;
-    mExpr = other.mExpr;
-    mTrivialDescription = other.mTrivialDescription;
-    return *this;
-}
+LiteralConstantExpression::LiteralConstantExpression(ScalarType::Kind kind, uint64_t value)
+  : LiteralConstantExpression(kind, value, std::to_string(value)) {}
 
-/* Literals. */
-ConstantExpression::ConstantExpression(const char *value)
-        : mExpr(value), mType(kConstExprLiteral), mTrivialDescription(true) {
-    const char* head = value, *tail = head + strlen(value) - 1;
+LiteralConstantExpression* LiteralConstantExpression::tryParse(const std::string& value) {
+    CHECK(!value.empty());
+
     bool isLong = false, isUnsigned = false;
-    bool isHex = (value[0] == '0' && (value[1] == 'x' || value[1] == 'X'));
-    while(tail >= head && (*tail == 'u' || *tail == 'U' || *tail == 'l' || *tail == 'L')) {
-        isUnsigned |= (*tail == 'u' || *tail == 'U');
-        isLong     |= (*tail == 'l' || *tail == 'L');
-        tail--;
+    bool isHex = (value[0] == '0' && value.length() > 1 && (value[1] == 'x' || value[1] == 'X'));
+
+    auto rbegin = value.rbegin();
+    auto rend = value.rend();
+    for (; rbegin != rend && (*rbegin == 'u' || *rbegin == 'U' || *rbegin == 'l' || *rbegin == 'L');
+         ++rbegin) {
+        isUnsigned |= (*rbegin == 'u' || *rbegin == 'U');
+        isLong |= (*rbegin == 'l' || *rbegin == 'L');
     }
-    char *newVal = strndup(value, tail - head + 1);
-    bool parseOK = base::ParseUint(newVal, &mValue);
-    free(newVal);
-    CHECK(parseOK) << "Could not parse as integer: " << value;
+    std::string newVal(value.begin(), rbegin.base());
+    CHECK(!newVal.empty());
+
+    uint64_t rawValue = 0;
+
+    bool parseOK = base::ParseUint(newVal, &rawValue);
+    if (!parseOK) {
+        return nullptr;
+    }
+
+    ScalarType::Kind kind;
 
     // guess literal type.
     if(isLong) {
         if(isUnsigned) // ul
-            mValueKind = SK(UINT64);
+            kind = SK(UINT64);
         else // l
-            mValueKind = SK(INT64);
+            kind = SK(INT64);
     } else { // no l suffix
         if(isUnsigned) { // u
-            if(mValue <= UINT32_MAX)
-                mValueKind = SK(UINT32);
+            if(rawValue <= UINT32_MAX)
+                kind = SK(UINT32);
             else
-                mValueKind = SK(UINT64);
+                kind = SK(UINT64);
         } else { // no suffix
             if(isHex) {
-                if(mValue <= INT32_MAX) // mValue always >= 0
-                    mValueKind = SK(INT32);
-                else if(mValue <= UINT32_MAX)
-                    mValueKind = SK(UINT32);
-                else if(mValue <= INT64_MAX) // mValue always >= 0
-                    mValueKind = SK(INT64);
-                else if(mValue <= UINT64_MAX)
-                    mValueKind = SK(UINT64);
-            } else {
-                if(mValue <= INT32_MAX) // mValue always >= 0
-                    mValueKind = SK(INT32);
+                if(rawValue <= INT32_MAX) // rawValue always >= 0
+                    kind = SK(INT32);
+                else if(rawValue <= UINT32_MAX)
+                    kind = SK(UINT32);
+                else if(rawValue <= INT64_MAX) // rawValue always >= 0
+                    kind = SK(INT64);
+                else if(rawValue <= UINT64_MAX)
+                    kind = SK(UINT64);
                 else
-                    mValueKind = SK(INT64);
+                    return nullptr;
+            } else {
+                if(rawValue <= INT32_MAX) // rawValue always >= 0
+                    kind = SK(INT32);
+                else
+                    kind = SK(INT64);
             }
         }
     }
+
+    return new LiteralConstantExpression(kind, rawValue, value);
 }
 
-/* Unary operations. */
-ConstantExpression::ConstantExpression(const char *op,
-                                       const ConstantExpression *value)
-        : mExpr(std::string("(") + op + value->mExpr + ")"),
-          mType(kConstExprUnary),
-          mValueKind(value->mValueKind) {
+void LiteralConstantExpression::evaluate() {
+    // Evaluated in constructor
+    CHECK(isEvaluated());
+}
 
-#define CASE_UNARY(__type__)\
-            mValue = handleUnary(op, static_cast<__type__>(value->mValue)); return;
+void UnaryConstantExpression::evaluate() {
+    if (isEvaluated()) return;
+    CHECK(mUnary->isEvaluated());
+    mIsEvaluated = true;
+
+    mExpr = std::string("(") + mOp + mUnary->description() + ")";
+    mValueKind = mUnary->mValueKind;
+
+#define CASE_UNARY(__type__)                                          \
+    mValue = handleUnary(mOp, static_cast<__type__>(mUnary->mValue)); \
+    return;
 
     SWITCH_KIND(mValueKind, CASE_UNARY, SHOULD_NOT_REACH(); return;)
 }
 
-/* Binary operations. */
-ConstantExpression::ConstantExpression(const ConstantExpression *lval,
-                                       const char *op,
-                                       const ConstantExpression* rval)
-        : mExpr(std::string("(") + lval->mExpr + " " + op + " " + rval->mExpr + ")"),
-          mType(kConstExprBinary)
-{
+void BinaryConstantExpression::evaluate() {
+    if (isEvaluated()) return;
+    CHECK(mLval->isEvaluated());
+    CHECK(mRval->isEvaluated());
+    mIsEvaluated = true;
+
+    mExpr = std::string("(") + mLval->description() + " " + mOp + " " + mRval->description() + ")";
 
     bool isArithmeticOrBitflip = OP_IS_BIN_ARITHMETIC || OP_IS_BIN_BITFLIP;
 
     // CASE 1: + - *  / % | ^ & < > <= >= == !=
     if(isArithmeticOrBitflip || OP_IS_BIN_COMP) {
         // promoted kind for both operands.
-        ScalarType::Kind promoted = usualArithmeticConversion(
-                integralPromotion(lval->mValueKind),
-                integralPromotion(rval->mValueKind));
+        ScalarType::Kind promoted = usualArithmeticConversion(integralPromotion(mLval->mValueKind),
+                                                              integralPromotion(mRval->mValueKind));
         // result kind.
         mValueKind = isArithmeticOrBitflip
                     ? promoted // arithmetic or bitflip operators generates promoted type
                     : SK(BOOL); // comparison operators generates bool
 
-#define CASE_BINARY_COMMON(__type__)\
-            mValue = handleBinaryCommon(static_cast<__type__>(lval->mValue), op, static_cast<__type__>(rval->mValue)); return;
+#define CASE_BINARY_COMMON(__type__)                                       \
+    mValue = handleBinaryCommon(static_cast<__type__>(mLval->mValue), mOp, \
+                                static_cast<__type__>(mRval->mValue));     \
+    return;
 
         SWITCH_KIND(promoted, CASE_BINARY_COMMON, SHOULD_NOT_REACH(); return;)
     }
 
     // CASE 2: << >>
+    std::string newOp = mOp;
     if(OP_IS_BIN_SHIFT) {
-        mValueKind = integralPromotion(lval->mValueKind);
+        mValueKind = integralPromotion(mLval->mValueKind);
         // instead of promoting rval, simply casting it to int64 should also be good.
-        int64_t numBits = rval->cast<int64_t>();
+        int64_t numBits = mRval->cast<int64_t>();
         if(numBits < 0) {
             // shifting with negative number of bits is undefined in C. In HIDL it
             // is defined as shifting into the other direction.
-            op = OPEQ("<<") ? ">>" : "<<";
+            newOp = OPEQ("<<") ? std::string(">>") : std::string("<<");
             numBits = -numBits;
         }
 
-#define CASE_SHIFT(__type__)\
-            mValue = handleShift(static_cast<__type__>(lval->mValue), op, numBits); return;
+#define CASE_SHIFT(__type__)                                                    \
+    mValue = handleShift(static_cast<__type__>(mLval->mValue), newOp, numBits); \
+    return;
 
         SWITCH_KIND(mValueKind, CASE_SHIFT, SHOULD_NOT_REACH(); return;)
     }
@@ -305,63 +316,79 @@
     if(OP_IS_BIN_LOGICAL) {
         mValueKind = SK(BOOL);
         // easy; everything is bool.
-        mValue = handleLogical(lval->mValue, op, rval->mValue);
+        mValue = handleLogical(mLval->mValue, mOp, mRval->mValue);
         return;
     }
 
     SHOULD_NOT_REACH();
 }
 
-/* Ternary ?: operation. */
-ConstantExpression::ConstantExpression(const ConstantExpression *cond,
-                                       const ConstantExpression *trueVal,
-                                       const ConstantExpression *falseVal)
-        : mExpr(std::string("(") + cond->mExpr + "?" + trueVal->mExpr
-                + ":" + falseVal->mExpr + ")"),
-          mType(kConstExprTernary) {
+void TernaryConstantExpression::evaluate() {
+    if (isEvaluated()) return;
+    CHECK(mCond->isEvaluated());
+    CHECK(mTrueVal->isEvaluated());
+    CHECK(mFalseVal->isEvaluated());
+    mIsEvaluated = true;
 
-    // note: for ?:, unlike arithmetic ops, integral promotion is not necessary.
-    mValueKind = usualArithmeticConversion(trueVal->mValueKind,
-                                           falseVal->mValueKind);
+    mExpr = std::string("(") + mCond->description() + "?" + mTrueVal->description() + ":" +
+            mFalseVal->description() + ")";
 
-#define CASE_TERNARY(__type__)\
-        mValue = cond->mValue ? (static_cast<__type__>(trueVal->mValue)) : (static_cast<__type__>(falseVal->mValue)); return;
+    // note: for ?:, unlike arithmetic ops, integral promotion is not processed.
+    mValueKind = usualArithmeticConversion(mTrueVal->mValueKind, mFalseVal->mValueKind);
+
+#define CASE_TERNARY(__type__)                                           \
+    mValue = mCond->mValue ? (static_cast<__type__>(mTrueVal->mValue))   \
+                           : (static_cast<__type__>(mFalseVal->mValue)); \
+    return;
 
     SWITCH_KIND(mValueKind, CASE_TERNARY, SHOULD_NOT_REACH(); return;)
 }
 
-ConstantExpression ConstantExpression::addOne() const {
-    ConstantExpression myOne = ConstantExpression::One(mValueKind);
-    return ConstantExpression(this, "+", &myOne).toLiteral();
+void ReferenceConstantExpression::evaluate() {
+    if (isEvaluated()) return;
+    CHECK(mReference->constExpr() != nullptr);
+
+    ConstantExpression* expr = mReference->constExpr();
+    CHECK(expr->isEvaluated());
+
+    mValueKind = expr->mValueKind;
+    mValue = expr->mValue;
+    mIsEvaluated = true;
 }
 
-ConstantExpression &ConstantExpression::toLiteral() {
-    mExpr = value();
-    mType = kConstExprLiteral;
-    return *this;
+std::unique_ptr<ConstantExpression> ConstantExpression::addOne(ScalarType::Kind baseKind) {
+    auto ret = std::make_unique<BinaryConstantExpression>(
+        this, "+", ConstantExpression::One(baseKind).release());
+    return ret;
 }
 
-const std::string &ConstantExpression::description() const {
+const std::string& ConstantExpression::description() const {
+    CHECK(isEvaluated());
     return mExpr;
 }
 
 bool ConstantExpression::descriptionIsTrivial() const {
+    CHECK(isEvaluated());
     return mTrivialDescription;
 }
 
 std::string ConstantExpression::value() const {
+    CHECK(isEvaluated());
     return rawValue(mValueKind);
 }
 
 std::string ConstantExpression::value(ScalarType::Kind castKind) const {
+    CHECK(isEvaluated());
     return rawValue(castKind);
 }
 
 std::string ConstantExpression::cppValue() const {
+    CHECK(isEvaluated());
     return cppValue(mValueKind);
 }
 
 std::string ConstantExpression::cppValue(ScalarType::Kind castKind) const {
+    CHECK(isEvaluated());
     std::string literal(rawValue(castKind));
     // this is a hack to translate
     //       enum x : int64_t {  y = 1l << 63 };
@@ -372,9 +399,9 @@
     // -(uint64_t)9223372036854775808 == 9223372036854775808 could not
     // be narrowed to int64_t.
     if(castKind == SK(INT64) && (int64_t)mValue == INT64_MIN) {
-        return strdup(("static_cast<"
-            + ScalarType(SK(INT64)).getCppStackType() // "int64_t"
-            + ">(" + literal + "ull)").c_str());
+        return "static_cast<" +
+               ScalarType(SK(INT64), nullptr /* parent */).getCppStackType()  // "int64_t"
+               + ">(" + literal + "ull)";
     }
 
     // add suffix if necessary.
@@ -384,10 +411,12 @@
 }
 
 std::string ConstantExpression::javaValue() const {
+    CHECK(isEvaluated());
     return javaValue(mValueKind);
 }
 
 std::string ConstantExpression::javaValue(ScalarType::Kind castKind) const {
+    CHECK(isEvaluated());
     switch(castKind) {
         case SK(UINT64): return rawValue(SK(INT64)) + "L";
         case SK(INT64):  return rawValue(SK(INT64)) + "L";
@@ -395,13 +424,14 @@
         case SK(UINT16): return rawValue(SK(INT16));
         case SK(UINT8) : return rawValue(SK(INT8));
         case SK(BOOL)  :
-            return this->cast<bool>() ? strdup("true") : strdup("false");
+            return this->cast<bool>() ? "true" : "false";
         default: break;
     }
     return rawValue(castKind);
 }
 
 std::string ConstantExpression::rawValue(ScalarType::Kind castKind) const {
+    CHECK(isEvaluated());
 
 #define CASE_STR(__type__) return std::to_string(this->cast<__type__>());
 
@@ -410,6 +440,7 @@
 
 template<typename T>
 T ConstantExpression::cast() const {
+    CHECK(isEvaluated());
 
 #define CASE_CAST_T(__type__) return static_cast<T>(static_cast<__type__>(mValue));
 
@@ -417,9 +448,213 @@
 }
 
 size_t ConstantExpression::castSizeT() const {
+    CHECK(isEvaluated());
     return this->cast<size_t>();
 }
 
+bool ConstantExpression::isReferenceConstantExpression() const {
+    return false;
+}
+
+std::vector<ConstantExpression*> ConstantExpression::getConstantExpressions() {
+    const auto& constRet = static_cast<const ConstantExpression*>(this)->getConstantExpressions();
+    std::vector<ConstantExpression*> ret(constRet.size());
+    std::transform(constRet.begin(), constRet.end(), ret.begin(),
+                   [](const auto* ce) { return const_cast<ConstantExpression*>(ce); });
+    return ret;
+}
+
+std::vector<Reference<LocalIdentifier>*> ConstantExpression::getReferences() {
+    const auto& constRet = static_cast<const ConstantExpression*>(this)->getReferences();
+    std::vector<Reference<LocalIdentifier>*> ret(constRet.size());
+    std::transform(constRet.begin(), constRet.end(), ret.begin(),
+                   [](const auto* ce) { return const_cast<Reference<LocalIdentifier>*>(ce); });
+    return ret;
+}
+
+std::vector<const Reference<LocalIdentifier>*> ConstantExpression::getReferences() const {
+    return {};
+}
+
+status_t ConstantExpression::recursivePass(const std::function<status_t(ConstantExpression*)>& func,
+                                           std::unordered_set<const ConstantExpression*>* visited,
+                                           bool processBeforeDependencies) {
+    if (mIsPostParseCompleted) return OK;
+
+    if (visited->find(this) != visited->end()) return OK;
+    visited->insert(this);
+
+    if (processBeforeDependencies) {
+        status_t err = func(this);
+        if (err != OK) return err;
+    }
+
+    for (auto* nextCE : getConstantExpressions()) {
+        status_t err = nextCE->recursivePass(func, visited, processBeforeDependencies);
+        if (err != OK) return err;
+    }
+
+    for (auto* nextRef : getReferences()) {
+        auto* nextCE = nextRef->shallowGet()->constExpr();
+        CHECK(nextCE != nullptr) << "Local identifier is not a constant expression";
+        status_t err = nextCE->recursivePass(func, visited, processBeforeDependencies);
+        if (err != OK) return err;
+    }
+
+    if (!processBeforeDependencies) {
+        status_t err = func(this);
+        if (err != OK) return err;
+    }
+
+    return OK;
+}
+
+status_t ConstantExpression::recursivePass(
+    const std::function<status_t(const ConstantExpression*)>& func,
+    std::unordered_set<const ConstantExpression*>* visited, bool processBeforeDependencies) const {
+    if (mIsPostParseCompleted) return OK;
+
+    if (visited->find(this) != visited->end()) return OK;
+    visited->insert(this);
+
+    if (processBeforeDependencies) {
+        status_t err = func(this);
+        if (err != OK) return err;
+    }
+
+    for (const auto* nextCE : getConstantExpressions()) {
+        status_t err = nextCE->recursivePass(func, visited, processBeforeDependencies);
+        if (err != OK) return err;
+    }
+
+    for (const auto* nextRef : getReferences()) {
+        const auto* nextCE = nextRef->shallowGet()->constExpr();
+        CHECK(nextCE != nullptr) << "Local identifier is not a constant expression";
+        status_t err = nextCE->recursivePass(func, visited, processBeforeDependencies);
+        if (err != OK) return err;
+    }
+
+    if (!processBeforeDependencies) {
+        status_t err = func(this);
+        if (err != OK) return err;
+    }
+
+    return OK;
+}
+
+ConstantExpression::CheckAcyclicStatus::CheckAcyclicStatus(
+    status_t status, const ConstantExpression* cycleEnd,
+    const ReferenceConstantExpression* lastReference)
+    : status(status), cycleEnd(cycleEnd), lastReference(lastReference) {
+    CHECK(cycleEnd == nullptr || status != OK);
+    CHECK((cycleEnd == nullptr) == (lastReference == nullptr));
+}
+
+ConstantExpression::CheckAcyclicStatus ConstantExpression::checkAcyclic(
+    std::unordered_set<const ConstantExpression*>* visited,
+    std::unordered_set<const ConstantExpression*>* stack) const {
+    if (stack->find(this) != stack->end()) {
+        CHECK(isReferenceConstantExpression())
+            << "Only reference constant expression could be the cycle end";
+
+        std::cerr << "ERROR: Cyclic declaration:\n";
+        return CheckAcyclicStatus(UNKNOWN_ERROR, this,
+                                  static_cast<const ReferenceConstantExpression*>(this));
+    }
+
+    if (visited->find(this) != visited->end()) return CheckAcyclicStatus(OK);
+    visited->insert(this);
+    stack->insert(this);
+
+    for (const auto* nextCE : getConstantExpressions()) {
+        auto err = nextCE->checkAcyclic(visited, stack);
+        if (err.status != OK) {
+            return err;
+        }
+    }
+
+    for (const auto* nextRef : getReferences()) {
+        const auto* nextCE = nextRef->shallowGet()->constExpr();
+        CHECK(nextCE != nullptr) << "Local identifier is not a constant expression";
+        auto err = nextCE->checkAcyclic(visited, stack);
+
+        if (err.status != OK) {
+            if (err.cycleEnd == nullptr) return err;
+
+            // Only ReferenceConstantExpression has references,
+            CHECK(isReferenceConstantExpression())
+                << "Only reference constant expression could have refereneces";
+
+            // mExpr is defined explicitly before evaluation
+            std::cerr << "  '" << err.lastReference->mExpr << "' in '" << mExpr << "' at "
+                      << nextRef->location() << "\n";
+
+            if (err.cycleEnd == this) {
+                return CheckAcyclicStatus(err.status);
+            }
+            return CheckAcyclicStatus(err.status, err.cycleEnd,
+                                      static_cast<const ReferenceConstantExpression*>(this));
+        }
+    }
+
+    CHECK(stack->find(this) != stack->end());
+    stack->erase(this);
+    return CheckAcyclicStatus(OK);
+}
+
+void ConstantExpression::setPostParseCompleted() {
+    CHECK(!mIsPostParseCompleted);
+    mIsPostParseCompleted = true;
+}
+
+std::vector<const ConstantExpression*> LiteralConstantExpression::getConstantExpressions() const {
+    return {};
+}
+
+UnaryConstantExpression::UnaryConstantExpression(const std::string& op, ConstantExpression* value)
+    : mUnary(value), mOp(op) {}
+
+std::vector<const ConstantExpression*> UnaryConstantExpression::getConstantExpressions() const {
+    return {mUnary};
+}
+
+BinaryConstantExpression::BinaryConstantExpression(ConstantExpression* lval, const std::string& op,
+                                                   ConstantExpression* rval)
+    : mLval(lval), mRval(rval), mOp(op) {}
+
+std::vector<const ConstantExpression*> BinaryConstantExpression::getConstantExpressions() const {
+    return {mLval, mRval};
+}
+
+TernaryConstantExpression::TernaryConstantExpression(ConstantExpression* cond,
+                                                     ConstantExpression* trueVal,
+                                                     ConstantExpression* falseVal)
+    : mCond(cond), mTrueVal(trueVal), mFalseVal(falseVal) {}
+
+std::vector<const ConstantExpression*> TernaryConstantExpression::getConstantExpressions() const {
+    return {mCond, mTrueVal, mFalseVal};
+}
+
+ReferenceConstantExpression::ReferenceConstantExpression(const Reference<LocalIdentifier>& value,
+                                                         const std::string& expr)
+    : mReference(value) {
+    mExpr = expr;
+    mTrivialDescription = mExpr.empty();
+}
+
+bool ReferenceConstantExpression::isReferenceConstantExpression() const {
+    return true;
+}
+
+std::vector<const ConstantExpression*> ReferenceConstantExpression::getConstantExpressions() const {
+    // Returns reference instead
+    return {};
+}
+
+std::vector<const Reference<LocalIdentifier>*> ReferenceConstantExpression::getReferences() const {
+    return {&mReference};
+}
+
 /*
 
 Evaluating expressions in HIDL language
diff --git a/ConstantExpression.h b/ConstantExpression.h
index 2c955d4..9784885 100644
--- a/ConstantExpression.h
+++ b/ConstantExpression.h
@@ -19,45 +19,80 @@
 #define CONSTANT_EXPRESSION_H_
 
 #include <android-base/macros.h>
+#include <functional>
+#include <memory>
 #include <string>
+#include <unordered_set>
+#include <vector>
+
+#include "Reference.h"
 #include "ScalarType.h"
 
 namespace android {
 
+struct LocalIdentifier;
+
+struct LiteralConstantExpression;
+struct UnaryConstantExpression;
+struct BinaryConstantExpression;
+struct TernaryConstantExpression;
+struct ReferenceConstantExpression;
+
 /**
  * A constant expression is represented by a tree.
  */
 struct ConstantExpression {
+    static std::unique_ptr<ConstantExpression> Zero(ScalarType::Kind kind);
+    static std::unique_ptr<ConstantExpression> One(ScalarType::Kind kind);
+    static std::unique_ptr<ConstantExpression> ValueOf(ScalarType::Kind kind, uint64_t value);
 
-    enum ConstExprType {
-        kConstExprLiteral,
-        kConstExprUnary,
-        kConstExprBinary,
-        kConstExprTernary
+    virtual ~ConstantExpression() {}
+
+    virtual bool isReferenceConstantExpression() const;
+
+    // Proceeds recursive pass
+    // Makes sure to visit each node only once
+    // Used to provide lookup and lazy evaluation
+    status_t recursivePass(const std::function<status_t(ConstantExpression*)>& func,
+                           std::unordered_set<const ConstantExpression*>* visited,
+                           bool processBeforeDependencies);
+    status_t recursivePass(const std::function<status_t(const ConstantExpression*)>& func,
+                           std::unordered_set<const ConstantExpression*>* visited,
+                           bool processBeforeDependencies) const;
+
+    // Evaluates current constant expression
+    // Doesn't call recursive evaluation, so must be called after dependencies
+    virtual void evaluate() = 0;
+
+    std::vector<ConstantExpression*> getConstantExpressions();
+    virtual std::vector<const ConstantExpression*> getConstantExpressions() const = 0;
+
+    std::vector<Reference<LocalIdentifier>*> getReferences();
+    virtual std::vector<const Reference<LocalIdentifier>*> getReferences() const;
+
+    // Recursive tree pass checkAcyclic return type.
+    // Stores cycle end for nice error messages.
+    struct CheckAcyclicStatus {
+        CheckAcyclicStatus(status_t status, const ConstantExpression* cycleEnd = nullptr,
+                           const ReferenceConstantExpression* lastReferenceExpression = nullptr);
+
+        status_t status;
+
+        // If a cycle is found, stores the end of cycle.
+        // While going back in recursion, this is used to stop printing the cycle.
+        const ConstantExpression* cycleEnd;
+
+        // The last ReferenceConstantExpression visited on the cycle.
+        const ReferenceConstantExpression* lastReference;
     };
 
-    /* Default constructor. */
-    ConstantExpression();
-    /* Copy constructor. */
-    ConstantExpression(const ConstantExpression& other);
-    /* Copy constructor, with the expr overriden. */
-    ConstantExpression(const ConstantExpression& other, std::string expr);
-    /* Literals */
-    ConstantExpression(const char *value);
-    /* binary operations */
-    ConstantExpression(const ConstantExpression *value1,
-        const char *op, const ConstantExpression* value2);
-    /* unary operations */
-    ConstantExpression(const char *op, const ConstantExpression *value);
-    /* ternary ?: */
-    ConstantExpression(const ConstantExpression *cond,
-                       const ConstantExpression *trueVal,
-                       const ConstantExpression *falseVal);
+    // Recursive tree pass that ensures that constant expressions definitions
+    // are acyclic.
+    CheckAcyclicStatus checkAcyclic(std::unordered_set<const ConstantExpression*>* visited,
+                                    std::unordered_set<const ConstantExpression*>* stack) const;
 
-    static ConstantExpression Zero(ScalarType::Kind kind);
-    static ConstantExpression One(ScalarType::Kind kind);
-    static ConstantExpression ValueOf(ScalarType::Kind kind, uint64_t value);
-
+    /* Returns true iff the value has already been evaluated. */
+    bool isEvaluated() const;
     /* Evaluated result in a string form. */
     std::string value() const;
     /* Evaluated result in a string form. */
@@ -70,22 +105,24 @@
     std::string cppValue(ScalarType::Kind castKind) const;
     /* Evaluated result in a string form, with given contextual kind. */
     std::string javaValue(ScalarType::Kind castKind) const;
-    /* Original expression with type. */
-    const std::string &description() const;
+    /* Formatted expression with type. */
+    const std::string& description() const;
     /* See mTrivialDescription */
     bool descriptionIsTrivial() const;
     /* Return a ConstantExpression that is 1 plus the original. */
-    ConstantExpression addOne() const;
-    /* Assignment operator. */
-    ConstantExpression& operator=(const ConstantExpression& other);
+    std::unique_ptr<ConstantExpression> addOne(ScalarType::Kind baseKind);
 
     size_t castSizeT() const;
 
-private:
+    // Marks that package proceeding is completed
+    // Post parse passes must be proceeded during owner package parsin
+    void setPostParseCompleted();
+
+   private:
+    /* If the result value has been evaluated. */
+    bool mIsEvaluated = false;
     /* The formatted expression. */
     std::string mExpr;
-    /* The type of the expression. Hints on its original form. */
-    ConstExprType mType;
     /* The kind of the result value. */
     ScalarType::Kind mValueKind;
     /* The stored result value. */
@@ -93,21 +130,85 @@
     /* true if description() does not offer more information than value(). */
     bool mTrivialDescription = false;
 
+    bool mIsPostParseCompleted = false;
+
     /*
      * Helper function for all cpp/javaValue methods.
      * Returns a plain string (without any prefixes or suffixes, just the
      * digits) converted from mValue.
      */
     std::string rawValue(ScalarType::Kind castKind) const;
-    /* Trim unnecessary information. Only mValue and mValueKind is kept. */
-    ConstantExpression &toLiteral();
 
     /*
      * Return the value casted to the given type.
      * First cast it according to mValueKind, then cast it to T.
      * Assumes !containsIdentifiers()
      */
-    template <typename T> T cast() const;
+    template <typename T>
+    T cast() const;
+
+    friend struct LiteralConstantExpression;
+    friend struct UnaryConstantExpression;
+    friend struct BinaryConstantExpression;
+    friend struct TernaryConstantExpression;
+    friend struct ReferenceConstantExpression;
+};
+
+struct LiteralConstantExpression : public ConstantExpression {
+    LiteralConstantExpression(ScalarType::Kind kind, uint64_t value);
+    void evaluate() override;
+    std::vector<const ConstantExpression*> getConstantExpressions() const override;
+
+    static LiteralConstantExpression* tryParse(const std::string& value);
+
+private:
+    LiteralConstantExpression(ScalarType::Kind kind, uint64_t value, const std::string& expr);
+};
+
+struct UnaryConstantExpression : public ConstantExpression {
+    UnaryConstantExpression(const std::string& mOp, ConstantExpression* value);
+    void evaluate() override;
+    std::vector<const ConstantExpression*> getConstantExpressions() const override;
+
+   private:
+    ConstantExpression* const mUnary;
+    std::string mOp;
+};
+
+struct BinaryConstantExpression : public ConstantExpression {
+    BinaryConstantExpression(ConstantExpression* lval, const std::string& op,
+                             ConstantExpression* rval);
+    void evaluate() override;
+    std::vector<const ConstantExpression*> getConstantExpressions() const override;
+
+   private:
+    ConstantExpression* const mLval;
+    ConstantExpression* const mRval;
+    const std::string mOp;
+};
+
+struct TernaryConstantExpression : public ConstantExpression {
+    TernaryConstantExpression(ConstantExpression* cond, ConstantExpression* trueVal,
+                              ConstantExpression* falseVal);
+    void evaluate() override;
+    std::vector<const ConstantExpression*> getConstantExpressions() const override;
+
+   private:
+    ConstantExpression* const mCond;
+    ConstantExpression* const mTrueVal;
+    ConstantExpression* const mFalseVal;
+};
+
+struct ReferenceConstantExpression : public ConstantExpression {
+    ReferenceConstantExpression(const Reference<LocalIdentifier>& value, const std::string& expr);
+
+    bool isReferenceConstantExpression() const override;
+    void evaluate() override;
+    std::vector<const ConstantExpression*> getConstantExpressions() const override;
+    std::vector<const Reference<LocalIdentifier>*> getReferences() const override;
+
+   private:
+    Reference<LocalIdentifier> mReference;
 };
 
 }  // namespace android
diff --git a/Coordinator.cpp b/Coordinator.cpp
index 8c89d5e..96c9658 100644
--- a/Coordinator.cpp
+++ b/Coordinator.cpp
@@ -25,11 +25,11 @@
 #include <android-base/logging.h>
 #include <hidl-hash/Hash.h>
 #include <hidl-util/StringHelper.h>
+#include <iostream>
 
 #include "AST.h"
 #include "Interface.h"
-
-extern android::status_t parseFile(android::AST *ast);
+#include "hidl-gen_l.h"
 
 static bool existdir(const char *name) {
     DIR *dir = opendir(name);
@@ -42,40 +42,200 @@
 
 namespace android {
 
-Coordinator::Coordinator(
-        const std::vector<std::string> &packageRootPaths,
-        const std::vector<std::string> &packageRoots,
-        const std::string &rootPath)
-    : mPackageRootPaths(packageRootPaths),
-      mPackageRoots(packageRoots),
-      mRootPath(rootPath) {
-    // empty
+const std::string &Coordinator::getRootPath() const {
+    return mRootPath;
 }
 
-Coordinator::~Coordinator() {
-    // empty
-}
+void Coordinator::setRootPath(const std::string &rootPath) {
+    mRootPath = rootPath;
 
-void Coordinator::addDefaultPackagePath(const std::string& root, const std::string& path) {
-    if (std::find(mPackageRoots.begin(), mPackageRoots.end(), root) == mPackageRoots.end()) {
-        mPackageRoots.push_back(root);
-        mPackageRootPaths.push_back(path);
+    if (!mRootPath.empty() && !StringHelper::EndsWith(mRootPath, "/")) {
+        mRootPath += "/";
     }
 }
 
+void Coordinator::setOutputPath(const std::string& outputPath) {
+    mOutputPath = outputPath;
+}
+
+void Coordinator::setVerbose(bool verbose) {
+    mVerbose = verbose;
+}
+
+bool Coordinator::isVerbose() const {
+    return mVerbose;
+}
+
+void Coordinator::setDepFile(const std::string& depFile) {
+    mDepFile = depFile;
+}
+
+const std::string& Coordinator::getOwner() const {
+    return mOwner;
+}
+void Coordinator::setOwner(const std::string& owner) {
+    mOwner = owner;
+}
+
+status_t Coordinator::addPackagePath(const std::string& root, const std::string& path, std::string* error) {
+    FQName package = FQName(root, "0.0", "");
+    for (const PackageRoot &packageRoot : mPackageRoots) {
+        if (packageRoot.root.inPackage(root) || package.inPackage(packageRoot.root.package())) {
+            if (error != nullptr) {
+                *error = "ERROR: conflicting package roots " +
+                         packageRoot.root.package() +
+                         " and " +
+                         root;
+            }
+
+            return UNKNOWN_ERROR;
+        }
+    }
+
+    mPackageRoots.push_back({path, package});
+    return OK;
+}
+void Coordinator::addDefaultPackagePath(const std::string& root, const std::string& path) {
+    addPackagePath(root, path, nullptr /* error */);
+}
+
+Formatter Coordinator::getFormatter(const FQName& fqName, Location location,
+                                    const std::string& fileName) const {
+    if (location == Location::STANDARD_OUT) {
+        return Formatter(stdout);
+    }
+
+    std::string filepath;
+    status_t err = getFilepath(fqName, location, fileName, &filepath);
+    if (err != OK) {
+        return Formatter::invalid();
+    }
+
+    onFileAccess(filepath, "w");
+
+    if (!Coordinator::MakeParentHierarchy(filepath)) {
+        fprintf(stderr, "ERROR: could not make directories for %s.\n", filepath.c_str());
+        return Formatter::invalid();
+    }
+
+    FILE* file = fopen(filepath.c_str(), "w");
+
+    if (file == nullptr) {
+        fprintf(stderr, "ERROR: could not open file %s: %d\n", filepath.c_str(), errno);
+        return Formatter::invalid();
+    }
+
+    return Formatter(file);
+}
+
+status_t Coordinator::getFilepath(const FQName& fqName, Location location,
+                                  const std::string& fileName, std::string* path) const {
+    status_t err;
+    std::string packagePath;
+    std::string packageRootPath;
+
+    switch (location) {
+        case Location::DIRECT: { /* nothing */
+            *path = mOutputPath + fileName;
+        } break;
+        case Location::PACKAGE_ROOT: {
+            err = getPackagePath(fqName, false /* relative */, false /* sanitized */, &packagePath);
+            if (err != OK) return err;
+
+            *path = mOutputPath + packagePath + fileName;
+        } break;
+        case Location::GEN_OUTPUT: {
+            err = convertPackageRootToPath(fqName, &packageRootPath);
+            if (err != OK) return err;
+            err = getPackagePath(fqName, true /* relative */, false /* sanitized */, &packagePath);
+            if (err != OK) return err;
+
+            *path = mOutputPath + packageRootPath + packagePath + fileName;
+        } break;
+        case Location::GEN_SANITIZED: {
+            err = convertPackageRootToPath(fqName, &packageRootPath);
+            if (err != OK) return err;
+            err = getPackagePath(fqName, true /* relative */, true /* sanitized */, &packagePath);
+            if (err != OK) return err;
+
+            *path = mOutputPath + packageRootPath + packagePath + fileName;
+        } break;
+        default: { CHECK(false) << "Invalid location: " << static_cast<size_t>(location); }
+    }
+
+    return OK;
+}
+
+void Coordinator::onFileAccess(const std::string& path, const std::string& mode) const {
+    if (mode == "r") {
+        // This is a global list. It's not cleared when a second fqname is processed for
+        // two reasons:
+        // 1). If there is a bug in hidl-gen, the dependencies on the first project from
+        //     the second would be required to recover correctly when the bug is fixed.
+        // 2). This option is never used in Android builds.
+        mReadFiles.insert(StringHelper::LTrim(path, mRootPath));
+    }
+
+    if (!mVerbose) {
+        return;
+    }
+
+    fprintf(stderr,
+            "VERBOSE: file access %s %s\n", path.c_str(), mode.c_str());
+}
+
+status_t Coordinator::writeDepFile(const std::string& forFile) const {
+    // No dep file requested
+    if (mDepFile.empty()) return OK;
+
+    onFileAccess(mDepFile, "w");
+
+    FILE* file = fopen(mDepFile.c_str(), "w");
+    if (file == nullptr) {
+        fprintf(stderr, "ERROR: could not open dep file at %s.\n", mDepFile.c_str());
+        return UNKNOWN_ERROR;
+    }
+
+    Formatter out(file, 2 /* spacesPerIndent */);
+    out << StringHelper::LTrim(forFile, mOutputPath) << ": \\\n";
+    out.indent([&] {
+        for (const std::string& file : mReadFiles) {
+            out << StringHelper::LTrim(file, mRootPath) << " \\\n";
+        }
+    });
+    return OK;
+}
+
 AST* Coordinator::parse(const FQName& fqName, std::set<AST*>* parsedASTs,
                         Enforce enforcement) const {
+    AST* ret;
+    status_t err = parseOptional(fqName, &ret, parsedASTs, enforcement);
+    if (err != OK) CHECK(ret == nullptr);  // internal consistency
+
+    // only in a handful of places do we want to distinguish between
+    // a missing file and a bad AST. Everywhere else, we just want to
+    // throw an error if we expect an AST to be present but it is not.
+    return ret;
+}
+
+status_t Coordinator::parseOptional(const FQName& fqName, AST** ast, std::set<AST*>* parsedASTs,
+                                    Enforce enforcement) const {
     CHECK(fqName.isFullyQualified());
 
     auto it = mCache.find(fqName);
     if (it != mCache.end()) {
-        AST *ast = (*it).second;
+        *ast = (*it).second;
 
-        if (ast != nullptr && parsedASTs != nullptr) {
-            parsedASTs->insert(ast);
+        if (*ast != nullptr && parsedASTs != nullptr) {
+            parsedASTs->insert(*ast);
         }
 
-        return ast;
+        if (*ast == nullptr) {
+            // circular import OR that AST has errors in it
+            return UNKNOWN_ERROR;
+        }
+
+        return OK;
     }
 
     // Add this to the cache immediately, so we can discover circular imports.
@@ -87,35 +247,47 @@
         // Any interface file implicitly imports its package's types.hal.
         FQName typesName = fqName.getTypesForPackage();
         // Do not enforce on imports. Do not add imports' imports to this AST.
-        typesAST = parse(typesName, nullptr, Enforce::NONE);
+        status_t err = parseOptional(typesName, &typesAST, nullptr, Enforce::NONE);
+        if (err != OK) return err;
 
         // fall through.
     }
 
-    std::string path = getAbsolutePackagePath(fqName);
+    std::string packagePath;
+    status_t err =
+        getPackagePath(fqName, false /* relative */, false /* sanitized */, &packagePath);
+    if (err != OK) return err;
 
-    path.append(fqName.name());
-    path.append(".hal");
+    const std::string path = makeAbsolute(packagePath + fqName.name() + ".hal");
 
-    AST *ast = new AST(this, path);
+    *ast = new AST(this, &Hash::getHash(path));
 
     if (typesAST != NULL) {
         // If types.hal for this AST's package existed, make it's defined
         // types available to the (about to be parsed) AST right away.
-        ast->addImportedAST(typesAST);
+        (*ast)->addImportedAST(typesAST);
     }
 
-    status_t err = parseFile(ast);
+    std::unique_ptr<FILE, std::function<void(FILE*)>> file(fopen(path.c_str(), "rb"), fclose);
 
-    if (err != OK) {
-        delete ast;
-        ast = nullptr;
-
-        return nullptr;
+    if (file == nullptr) {
+        mCache.erase(fqName);  // nullptr in cache is used to find circular imports
+        delete *ast;
+        *ast = nullptr;
+        return OK;  // File does not exist, nullptr AST* == file doesn't exist.
     }
 
-    if (ast->package().package() != fqName.package()
-            || ast->package().version() != fqName.version()) {
+    onFileAccess(path, "r");
+
+    // parse file takes ownership of file
+    if (parseFile(*ast, std::move(file)) != OK || (*ast)->postParse() != OK) {
+        delete *ast;
+        *ast = nullptr;
+        return UNKNOWN_ERROR;
+    }
+
+    if ((*ast)->package().package() != fqName.package() ||
+        (*ast)->package().version() != fqName.version()) {
         fprintf(stderr,
                 "ERROR: File at '%s' does not match expected package and/or "
                 "version.\n",
@@ -123,16 +295,15 @@
 
         err = UNKNOWN_ERROR;
     } else {
-        if (ast->isInterface()) {
+        if ((*ast)->isInterface()) {
             if (fqName.name() == "types") {
                 fprintf(stderr,
                         "ERROR: File at '%s' declares an interface '%s' "
                         "instead of the expected types common to the package.\n",
-                        path.c_str(),
-                        ast->getInterface()->localName().c_str());
+                        path.c_str(), (*ast)->getInterface()->localName().c_str());
 
                 err = UNKNOWN_ERROR;
-            } else if (ast->getInterface()->localName() != fqName.name()) {
+            } else if ((*ast)->getInterface()->localName() != fqName.name()) {
                 fprintf(stderr,
                         "ERROR: File at '%s' does not declare interface type "
                         "'%s'.\n",
@@ -149,7 +320,7 @@
                     fqName.name().c_str());
 
             err = UNKNOWN_ERROR;
-        } else if (ast->containsInterfaces()) {
+        } else if ((*ast)->containsInterfaces()) {
             fprintf(stderr,
                     "ERROR: types.hal file at '%s' declares at least one "
                     "interface type.\n",
@@ -160,32 +331,32 @@
     }
 
     if (err != OK) {
-        delete ast;
-        ast = nullptr;
-
-        return nullptr;
+        delete *ast;
+        *ast = nullptr;
+        return err;
     }
 
-    if (parsedASTs != nullptr) { parsedASTs->insert(ast); }
+    if (parsedASTs != nullptr) {
+        parsedASTs->insert(*ast);
+    }
 
     // put it into the cache now, so that enforceRestrictionsOnPackage can
     // parse fqName.
-    mCache[fqName] = ast;
+    mCache[fqName] = *ast;
 
     // For each .hal file that hidl-gen parses, the whole package will be checked.
     err = enforceRestrictionsOnPackage(fqName, enforcement);
     if (err != OK) {
         mCache[fqName] = nullptr;
-        delete ast;
-        ast = nullptr;
-        return nullptr;
+        delete *ast;
+        *ast = nullptr;
+        return err;
     }
 
-    return ast;
+    return OK;
 }
 
-std::vector<std::string>::const_iterator
-Coordinator::findPackageRoot(const FQName &fqName) const {
+const Coordinator::PackageRoot* Coordinator::findPackageRoot(const FQName& fqName) const {
     CHECK(!fqName.package().empty());
 
     // Find the right package prefix and path for this FQName.  For
@@ -195,92 +366,77 @@
     // prefix "android.hardware" and the package root
     // "hardware/interfaces".
 
-    auto it = mPackageRoots.begin();
     auto ret = mPackageRoots.end();
-    for (; it != mPackageRoots.end(); it++) {
-        if (!fqName.inPackage(*it)) {
+    for (auto it = mPackageRoots.begin(); it != mPackageRoots.end(); it++) {
+        if (!fqName.inPackage(it->root.package())) {
             continue;
         }
 
-        CHECK(ret == mPackageRoots.end())
-            << "Multiple package roots found for " << fqName.string()
-            << " (" << *it << " and " << *ret << ")";
+        if (ret != mPackageRoots.end()) {
+            std::cerr << "ERROR: Multiple package roots found for " << fqName.string() << " ("
+                      << it->root.package() << " and " << ret->root.package() << ")\n";
+            return nullptr;
+        }
 
         ret = it;
     }
-    CHECK(ret != mPackageRoots.end())
-        << "Unable to find package root for " << fqName.string();
 
-    return ret;
-}
-
-std::string Coordinator::getAbsolutePackagePath(const FQName& fqName) const {
-    const std::string packagePath = getPackagePath(fqName);
-
-    if (StringHelper::StartsWith(packagePath, "/") || mRootPath.empty()) {
-        return packagePath;
+    if (ret == mPackageRoots.end()) {
+        std::cerr << "ERROR: Package root not specified for " << fqName.string() << "\n";
+        return nullptr;
     }
 
-    return StringHelper::RTrim(mRootPath, "/") + "/" + packagePath;
+    return &(*ret);
 }
 
-std::string Coordinator::getPackageRoot(const FQName &fqName) const {
-    auto it = findPackageRoot(fqName);
-    auto prefix = *it;
-    return prefix;
-}
-
-std::string Coordinator::getPackageRootPath(const FQName &fqName) const {
-    auto it = findPackageRoot(fqName);
-    auto root = mPackageRootPaths[std::distance(mPackageRoots.begin(), it)];
-    return root;
-}
-
-std::string Coordinator::getPackageRootOption(const FQName &fqName) const {
-    return getPackageRoot(fqName) + ":" + getPackageRootPath(fqName);
-}
-
-std::string Coordinator::getPackagePath(
-        const FQName &fqName, bool relative, bool sanitized) const {
-
-    auto it = findPackageRoot(fqName);
-    auto prefix = *it;
-    auto root = mPackageRootPaths[std::distance(mPackageRoots.begin(), it)];
-
-    // Make sure the prefix ends on a '.' and the root path on a '/'
-    if ((*--prefix.end()) != '.') {
-        prefix += '.';
+std::string Coordinator::makeAbsolute(const std::string& path) const {
+    if (StringHelper::StartsWith(path, "/") || mRootPath.empty()) {
+        return path;
     }
 
-    if ((*--root.end()) != '/') {
-        root += '/';
+    return mRootPath + path;
+}
+
+status_t Coordinator::getPackageRoot(const FQName& fqName, std::string* root) const {
+    const PackageRoot* packageRoot = findPackageRoot(fqName);
+    if (root == nullptr) {
+        return UNKNOWN_ERROR;
     }
+    *root = packageRoot->root.package();
+    return OK;
+}
 
-    // Given FQName of "android.hardware.nfc@1.0::IFoo" and a prefix
-    // "android.hardware.", the suffix is "nfc@1.0::IFoo".
-    const std::string packageSuffix = fqName.package().substr(prefix.length());
+status_t Coordinator::getPackageRootPath(const FQName& fqName, std::string* path) const {
+    const PackageRoot* packageRoot = findPackageRoot(fqName);
+    if (packageRoot == nullptr) {
+        return UNKNOWN_ERROR;
+    }
+    *path = packageRoot->path;
+    return OK;
+}
 
-    std::string packagePath;
+status_t Coordinator::getPackagePath(const FQName& fqName, bool relative, bool sanitized,
+                                     std::string* path) const {
+    const PackageRoot* packageRoot = findPackageRoot(fqName);
+    if (packageRoot == nullptr) return UNKNOWN_ERROR;
+
+    // Given FQName of "android.hardware.nfc.test@1.0::IFoo" and a prefix
+    // "android.hardware", the suffix is "nfc.test".
+    std::string suffix = StringHelper::LTrim(fqName.package(), packageRoot->root.package());
+    suffix = StringHelper::LTrim(suffix, ".");
+
+    std::vector<std::string> suffixComponents;
+    StringHelper::SplitString(suffix, '.', &suffixComponents);
+
+    std::vector<std::string> components;
     if (!relative) {
-        packagePath = root;
+        components.push_back(StringHelper::RTrimAll(packageRoot->path, "/"));
     }
+    components.insert(components.end(), suffixComponents.begin(), suffixComponents.end());
+    components.push_back(sanitized ? fqName.sanitizedVersion() : fqName.version());
 
-    size_t startPos = 0;
-    size_t dotPos;
-    while ((dotPos = packageSuffix.find('.', startPos)) != std::string::npos) {
-        packagePath.append(packageSuffix.substr(startPos, dotPos - startPos));
-        packagePath.append("/");
-
-        startPos = dotPos + 1;
-    }
-    CHECK_LT(startPos + 1, packageSuffix.length());
-    packagePath.append(packageSuffix.substr(startPos));
-    packagePath.append("/");
-
-    packagePath.append(sanitized ? fqName.sanitizedVersion() : fqName.version());
-    packagePath.append("/");
-
-    return packagePath;
+    *path = StringHelper::JoinStrings(components, "/") + "/";
+    return OK;
 }
 
 status_t Coordinator::getPackageInterfaceFiles(
@@ -288,16 +444,17 @@
         std::vector<std::string> *fileNames) const {
     fileNames->clear();
 
-    const std::string packagePath = getAbsolutePackagePath(package);
+    std::string packagePath;
+    status_t err =
+        getPackagePath(package, false /* relative */, false /* sanitized */, &packagePath);
+    if (err != OK) return err;
 
-    DIR *dir = opendir(packagePath.c_str());
+    const std::string path = makeAbsolute(packagePath);
+    DIR* dir = opendir(path.c_str());
 
     if (dir == NULL) {
-        fprintf(stderr,
-                "ERROR: Could not open package path %s for package %s:\n%s\n",
-                getPackagePath(package).c_str(),
-                package.string().c_str(),
-                packagePath.c_str());
+        fprintf(stderr, "ERROR: Could not open package path %s for package %s:\n%s\n",
+                packagePath.c_str(), package.string().c_str(), path.c_str());
         return -errno;
     }
 
@@ -349,28 +506,17 @@
     }
 
     for (const auto &fileName : fileNames) {
-        FQName subFQName(
-                package.package() + package.atVersion() + "::" + fileName);
-
-        if (!subFQName.isValid()) {
-            LOG(WARNING)
-                << "Whole-package import encountered invalid filename '"
-                << fileName
-                << "' in package "
-                << package.package()
-                << package.atVersion();
-
-            continue;
-        }
-
+        FQName subFQName(package.package(), package.version(), fileName);
         packageInterfaces->push_back(subFQName);
     }
 
     return OK;
 }
 
-std::string Coordinator::convertPackageRootToPath(const FQName &fqName) const {
-    std::string packageRoot = getPackageRoot(fqName);
+status_t Coordinator::convertPackageRootToPath(const FQName& fqName, std::string* path) const {
+    std::string packageRoot;
+    status_t err = getPackageRoot(fqName, &packageRoot);
+    if (err != OK) return err;
 
     if (*(packageRoot.end()--) != '.') {
         packageRoot += '.';
@@ -378,7 +524,85 @@
 
     std::replace(packageRoot.begin(), packageRoot.end(), '.', '/');
 
-    return packageRoot; // now converted to a path
+    *path = packageRoot;  // now converted to a path
+    return OK;
+}
+
+status_t Coordinator::isTypesOnlyPackage(const FQName& package, bool* result) const {
+    std::vector<FQName> packageInterfaces;
+
+    status_t err = appendPackageInterfacesToVector(package, &packageInterfaces);
+
+    if (err != OK) {
+        *result = false;
+        return err;
+    }
+
+    *result = packageInterfaces.size() == 1 && packageInterfaces[0].name() == "types";
+    return OK;
+}
+
+status_t Coordinator::addUnreferencedTypes(const std::vector<FQName>& packageInterfaces,
+                                           std::set<FQName>* unreferencedDefinitions,
+                                           std::set<FQName>* unreferencedImports) const {
+    CHECK(unreferencedDefinitions != nullptr);
+    CHECK(unreferencedImports != nullptr);
+
+    std::set<FQName> packageDefinedTypes;
+    std::set<FQName> packageReferencedTypes;
+    std::set<FQName> packageImportedTypes;
+    std::set<FQName> typesDefinedTypes;  // only types.hal types
+
+    for (const auto& fqName : packageInterfaces) {
+        AST* ast = parse(fqName);
+        if (!ast) {
+            std::cerr << "ERROR: Could not parse " << fqName.string() << ". Aborting." << std::endl;
+
+            return UNKNOWN_ERROR;
+        }
+
+        ast->addDefinedTypes(&packageDefinedTypes);
+        ast->addReferencedTypes(&packageReferencedTypes);
+        ast->getAllImportedNamesGranular(&packageImportedTypes);
+
+        if (fqName.name() == "types") {
+            ast->addDefinedTypes(&typesDefinedTypes);
+        }
+    }
+
+#if 0
+    for (const auto &fqName : packageDefinedTypes) {
+        std::cout << "VERBOSE: DEFINED " << fqName.string() << std::endl;
+    }
+
+    for (const auto &fqName : packageImportedTypes) {
+        std::cout << "VERBOSE: IMPORTED " << fqName.string() << std::endl;
+    }
+
+    for (const auto &fqName : packageReferencedTypes) {
+        std::cout << "VERBOSE: REFERENCED " << fqName.string() << std::endl;
+    }
+
+    for (const auto &fqName : typesDefinedTypes) {
+        std::cout << "VERBOSE: DEFINED in types.hal " << fqName.string() << std::endl;
+    }
+#endif
+
+    for (const auto& fqName : packageReferencedTypes) {
+        packageDefinedTypes.erase(fqName);
+        packageImportedTypes.erase(fqName);
+    }
+
+    // A package implicitly imports its own types.hal, only track them in one set.
+    for (const auto& fqName : typesDefinedTypes) {
+        packageImportedTypes.erase(fqName);
+    }
+
+    // defined but not referenced
+    unreferencedDefinitions->insert(packageDefinedTypes.begin(), packageDefinedTypes.end());
+    // imported but not referenced
+    unreferencedImports->insert(packageImportedTypes.begin(), packageImportedTypes.end());
+    return OK;
 }
 
 status_t Coordinator::enforceRestrictionsOnPackage(const FQName& fqName,
@@ -389,8 +613,8 @@
     // need fqName to be something like android.hardware.foo@1.0.
     // name and valueName is ignored.
     if (fqName.package().empty() || fqName.version().empty()) {
-        LOG(ERROR) << "Cannot enforce restrictions on package " << fqName.string()
-                   << ": package or version is missing.";
+        std::cerr << "ERROR: Cannot enforce restrictions on package " << fqName.string()
+                  << ": package or version is missing." << std::endl;
         return BAD_VALUE;
     }
 
@@ -407,7 +631,7 @@
     // enforce all rules.
     status_t err;
 
-    err = enforceMinorVersionUprevs(package);
+    err = enforceMinorVersionUprevs(package, enforcement);
     if (err != OK) {
         return err;
     }
@@ -424,10 +648,11 @@
     return OK;
 }
 
-status_t Coordinator::enforceMinorVersionUprevs(const FQName &currentPackage) const {
+status_t Coordinator::enforceMinorVersionUprevs(const FQName& currentPackage,
+                                                Enforce enforcement) const {
     if(!currentPackage.hasVersion()) {
-        LOG(ERROR) << "Cannot enforce minor version uprevs for " << currentPackage.string()
-                   << ": missing version.";
+        std::cerr << "ERROR: Cannot enforce minor version uprevs for " << currentPackage.string()
+                  << ": missing version." << std::endl;
         return UNKNOWN_ERROR;
     }
 
@@ -439,7 +664,13 @@
     FQName prevPackage = currentPackage;
     while (prevPackage.getPackageMinorVersion() > 0) {
         prevPackage = prevPackage.downRev();
-        if (existdir(getAbsolutePackagePath(prevPackage).c_str())) {
+
+        std::string prevPackagePath;
+        status_t err = getPackagePath(prevPackage, false /* relative */, false /* sanitized */,
+                                      &prevPackagePath);
+        if (err != OK) return err;
+
+        if (existdir(makeAbsolute(prevPackagePath).c_str())) {
             hasPrevPackage = true;
             break;
         }
@@ -450,13 +681,22 @@
     }
 
     if (prevPackage != currentPackage.downRev()) {
-        LOG(ERROR) << "Cannot enforce minor version uprevs for " << currentPackage.string()
-                   << ": Found package " << prevPackage.string() << " but missing "
-                   << currentPackage.downRev().string() << "; you cannot skip a minor version.";
+        std::cerr << "ERROR: Cannot enforce minor version uprevs for " << currentPackage.string()
+                  << ": Found package " << prevPackage.string() << " but missing "
+                  << currentPackage.downRev().string() << "; you cannot skip a minor version."
+                  << std::endl;
         return UNKNOWN_ERROR;
     }
 
-    status_t err;
+    bool prevIsTypesOnly;
+    status_t err = isTypesOnlyPackage(prevPackage, &prevIsTypesOnly);
+    if (err != OK) return err;
+
+    if (prevIsTypesOnly) {
+        // A types only package can be extended in any way.
+        return OK;
+    }
+
     std::vector<FQName> packageInterfaces;
     err = appendPackageInterfacesToVector(currentPackage, &packageInterfaces);
     if (err != OK) {
@@ -470,19 +710,20 @@
         }
 
         const Interface *iface = nullptr;
-        AST *currentAST = parse(currentFQName);
+        AST* currentAST = parse(currentFQName, nullptr /* parsedASTs */, enforcement);
         if (currentAST != nullptr) {
             iface = currentAST->getInterface();
         }
         if (iface == nullptr) {
             if (currentAST == nullptr) {
-                LOG(WARNING) << "Warning: Skipping " << currentFQName.string()
-                             << " because it could not be found or parsed"
-                             << " or " << currentPackage.string()
-                             << " doesn't pass all requirements.";
+                std::cerr << "WARNING: Skipping " << currentFQName.string()
+                          << " because it could not be found or parsed"
+                          << " or " << currentPackage.string() << " doesn't pass all requirements."
+                          << std::endl;
             } else {
-                LOG(WARNING) << "Warning: Skipping " << currentFQName.string()
-                             << " because the file might contain more than one interface.";
+                std::cerr << "WARNING: Skipping " << currentFQName.string()
+                          << " because the file might contain more than one interface."
+                          << std::endl;
             }
             continue;
         }
@@ -508,73 +749,144 @@
 
         bool lastFQNameExists = lastAST != nullptr && lastAST->getInterface() != nullptr;
 
-        if (iface->superType()->fqName() != lastFQName && lastFQNameExists) {
-            LOG(ERROR) << "Cannot enforce minor version uprevs for " << currentPackage.string()
-                       << ": " << iface->fqName().string() << " extends "
-                       << iface->superType()->fqName().string()
-                       << ", which is not allowed. It must extend " << lastFQName.string();
+        if (!lastFQNameExists) {
+            continue;
+        }
+
+        if (iface->superType()->fqName() != lastFQName) {
+            std::cerr << "ERROR: Cannot enforce minor version uprevs for "
+                      << currentPackage.string() << ": " << iface->fqName().string() << " extends "
+                      << iface->superType()->fqName().string()
+                      << ", which is not allowed. It must extend " << lastFQName.string()
+                      << std::endl;
             return UNKNOWN_ERROR;
         }
 
         // at least one interface must extend the previous version
+        // @2.0::IFoo does not work. It must be @2.1::IFoo for at least one interface.
         if (lastFQName.getPackageAndVersion() == prevPackage.getPackageAndVersion()) {
             extendedInterface = true;
         }
 
-        LOG(VERBOSE) << "enforceMinorVersionUprevs: " << currentFQName.string() << " passes.";
+        if (mVerbose) {
+            std::cout << "VERBOSE: EnforceMinorVersionUprevs: " << currentFQName.string()
+                      << " passes." << std::endl;
+        }
     }
 
     if (!extendedInterface) {
         // No interface extends the interface with the same name in @x.(y-1).
-        LOG(ERROR) << currentPackage.string() << " doesn't pass minor version uprev requirement. "
-                   << "Requires at least one interface to extend an interface with the same name "
-                   << "from " << prevPackage.string() << ".";
+        std::cerr << "ERROR: " << currentPackage.string()
+                  << " doesn't pass minor version uprev requirement. "
+                  << "Requires at least one interface to extend an interface with the same name "
+                  << "from " << prevPackage.string() << "." << std::endl;
         return UNKNOWN_ERROR;
     }
 
     return OK;
 }
 
-status_t Coordinator::enforceHashes(const FQName &currentPackage) const {
-    status_t err = OK;
+Coordinator::HashStatus Coordinator::checkHash(const FQName& fqName) const {
+    AST* ast = parse(fqName);
+    if (ast == nullptr) return HashStatus::ERROR;
+
+    std::string rootPath;
+    status_t err = getPackageRootPath(fqName, &rootPath);
+    if (err != OK) return HashStatus::ERROR;
+
+    std::string hashPath = makeAbsolute(rootPath) + "/current.txt";
+    std::string error;
+    bool fileExists;
+    std::vector<std::string> frozen =
+        Hash::lookupHash(hashPath, fqName.string(), &error, &fileExists);
+    if (fileExists) onFileAccess(hashPath, "r");
+
+    if (error.size() > 0) {
+        std::cerr << "ERROR: " << error << std::endl;
+        return HashStatus::ERROR;
+    }
+
+    // hash not defined, interface not frozen
+    if (frozen.size() == 0) {
+        // This ensures that it can be detected.
+        Hash::clearHash(ast->getFilename());
+
+        return HashStatus::UNFROZEN;
+    }
+
+    std::string currentHash = ast->getFileHash()->hexString();
+
+    if (std::find(frozen.begin(), frozen.end(), currentHash) == frozen.end()) {
+        std::cerr << "ERROR: " << fqName.string() << " has hash " << currentHash
+                  << " which does not match hash on record. This interface has "
+                  << "been frozen. Do not change it!" << std::endl;
+        return HashStatus::CHANGED;
+    }
+
+    return HashStatus::FROZEN;
+}
+
+status_t Coordinator::getUnfrozenDependencies(const FQName& fqName,
+                                              std::set<FQName>* result) const {
+    CHECK(result != nullptr);
+
+    AST* ast = parse(fqName);
+    if (ast == nullptr) return UNKNOWN_ERROR;
+
+    std::set<FQName> imported;
+    ast->getImportedPackages(&imported);
+
+    // no circular dependency is already guaranteed by parsing
+    // indirect dependencies will be checked when the imported interface frozen checks are done
+    for (const FQName& importedPackage : imported) {
+        std::vector<FQName> packageInterfaces;
+        status_t err = appendPackageInterfacesToVector(importedPackage, &packageInterfaces);
+        if (err != OK) {
+            return err;
+        }
+
+        for (const FQName& importedName : packageInterfaces) {
+            HashStatus status = checkHash(importedName);
+            if (status == HashStatus::ERROR) return UNKNOWN_ERROR;
+            if (status == HashStatus::UNFROZEN) {
+                result->insert(importedName);
+            }
+        }
+    }
+
+    return OK;
+}
+
+status_t Coordinator::enforceHashes(const FQName& currentPackage) const {
     std::vector<FQName> packageInterfaces;
-    err = appendPackageInterfacesToVector(currentPackage, &packageInterfaces);
+    status_t err = appendPackageInterfacesToVector(currentPackage, &packageInterfaces);
     if (err != OK) {
         return err;
     }
 
-    for (const FQName &currentFQName : packageInterfaces) {
-        AST *ast = parse(currentFQName);
+    for (const FQName& currentFQName : packageInterfaces) {
+        HashStatus status = checkHash(currentFQName);
 
-        if (ast == nullptr) {
-            err = UNKNOWN_ERROR;
-            continue;
+        if (status == HashStatus::ERROR) return UNKNOWN_ERROR;
+        if (status == HashStatus::CHANGED) return UNKNOWN_ERROR;
+
+        // frozen interface can only depend on a frozen interface
+        if (status == HashStatus::FROZEN) {
+            std::set<FQName> unfrozenDependencies;
+            err = getUnfrozenDependencies(currentFQName, &unfrozenDependencies);
+            if (err != OK) return err;
+
+            if (!unfrozenDependencies.empty()) {
+                std::cerr << "ERROR: Frozen interface " << currentFQName.string()
+                          << " cannot depend on unfrozen thing(s):" << std::endl;
+                for (const FQName& name : unfrozenDependencies) {
+                    std::cerr << " (unfrozen) " << name.string() << std::endl;
+                }
+                return UNKNOWN_ERROR;
+            }
         }
 
-        std::string hashPath = getPackageRootPath(currentFQName) + "/current.txt";
-        std::string error;
-        std::vector<std::string> frozen = Hash::lookupHash(hashPath, currentFQName.string(), &error);
-
-        if (error.size() > 0) {
-            LOG(ERROR) << error;
-            err = UNKNOWN_ERROR;
-            continue;
-        }
-
-        // hash not define, interface not frozen
-        if (frozen.size() == 0) {
-            continue;
-        }
-
-        std::string currentHash = Hash::getHash(ast->getFilename()).hexString();
-
-        if(std::find(frozen.begin(), frozen.end(), currentHash) == frozen.end()) {
-            LOG(ERROR) << currentFQName.string() << " has hash " << currentHash
-                       << " which does not match hash on record. This interface has "
-                       << "been frozen. Do not change it!";
-            err = UNKNOWN_ERROR;
-            continue;
-        }
+        // UNFROZEN, ignore
     }
 
     return err;
@@ -585,7 +897,7 @@
 
     size_t start = 1;  // Ignore leading '/'
     size_t slashPos;
-    while ((slashPos = path.find("/", start)) != std::string::npos) {
+    while ((slashPos = path.find('/', start)) != std::string::npos) {
         std::string partial = path.substr(0, slashPos);
 
         struct stat st;
diff --git a/Coordinator.h b/Coordinator.h
index 2e761df..2dd1ca3 100644
--- a/Coordinator.h
+++ b/Coordinator.h
@@ -19,30 +19,58 @@
 #define COORDINATOR_H_
 
 #include <android-base/macros.h>
-#include <functional>
+#include <hidl-util/FQName.h>
+#include <hidl-util/Formatter.h>
+#include <utils/Errors.h>
 #include <map>
 #include <set>
 #include <string>
-#include <utils/Errors.h>
 #include <vector>
 
 namespace android {
 
 struct AST;
-struct FQName;
 struct Type;
 
 struct Coordinator {
-    Coordinator(
-            const std::vector<std::string> &packageRootPaths,
-            const std::vector<std::string> &packageRoots,
-            const std::string &rootPath);
+    Coordinator() {};
 
-    ~Coordinator();
+    const std::string& getRootPath() const;
+    void setRootPath(const std::string &rootPath);
+    void setOutputPath(const std::string& outputPath);
+
+    void setVerbose(bool value);
+    bool isVerbose() const;
+
+    void setDepFile(const std::string& depFile);
+
+    const std::string& getOwner() const;
+    void setOwner(const std::string& owner);
 
     // adds path only if it doesn't exist
+    status_t addPackagePath(const std::string& root, const std::string& path, std::string* error);
+    // adds path if it hasn't already been added
     void addDefaultPackagePath(const std::string& root, const std::string& path);
 
+    enum class Location {
+        STANDARD_OUT,
+        DIRECT,         // mOutputPath + file name
+        PACKAGE_ROOT,   // e.x. mRootPath + /nfc/1.0/Android.bp
+        GEN_OUTPUT,     // e.x. mOutputPath + /android/hardware/foo/1.0/*.cpp
+        GEN_SANITIZED,  // e.x. mOutputPath + /android/hardware/foo/V1_0/*.cpp
+    };
+
+    status_t getFilepath(const FQName& fqName, Location location, const std::string& fileName,
+                         std::string* path) const;
+
+    Formatter getFormatter(const FQName& fqName, Location location,
+                           const std::string& fileName) const;
+
+    // must be called before file access
+    void onFileAccess(const std::string& path, const std::string& mode) const;
+
+    status_t writeDepFile(const std::string& forFile) const;
+
     enum class Enforce {
         FULL,     // default
         NO_HASH,  // only for use with -Lhash
@@ -58,35 +86,29 @@
     AST* parse(const FQName& fqName, std::set<AST*>* parsedASTs = nullptr,
                Enforce enforcement = Enforce::FULL) const;
 
+    // Same as parse, but it distinguishes between "missing file" and "could not parse AST"
+    // return OK, out *ast:
+    //    0xdeadbeef -> successfully parsed
+    //    nullptr    -> file not present
+    // return !OK
+    //    could not parse AST and file exists
+    status_t parseOptional(const FQName& fqName, AST** ast, std::set<AST*>* parsedASTs = nullptr,
+                           Enforce enforcement = Enforce::FULL) const;
+
     // Given package-root paths of ["hardware/interfaces",
     // "vendor/<something>/interfaces"], package roots of
     // ["android.hardware", "vendor.<something>.hardware"], and a
     // FQName of "android.hardware.nfc@1.0::INfc, then getPackagePath()
     // will return "hardware/interfaces/nfc/1.0" (if sanitized = false)
     // or "hardware/interfaces/nfc/V1_0" (if sanitized = true).
-    std::string getPackagePath(
-            const FQName &fqName, bool relative = false,
-            bool sanitized = false) const;
+    status_t getPackagePath(const FQName& fqName, bool relative, bool sanitized,
+                            std::string* path) const;
 
     // Given package roots of ["android.hardware",
     // "vendor.<something>.hardware"] and a FQName of
     // "android.hardware.nfc@1.0::INfc, then getPackageRoot() will
     // return "android.hardware".
-    std::string getPackageRoot(const FQName &fqName) const;
-
-    // Given package-root paths of ["hardware/interfaces",
-    // "vendor/<something>/interfaces"], package roots of
-    // ["android.hardware", "vendor.<something>.hardware"], and a
-    // FQName of "android.hardware.nfc@1.0::INfc, then getPackageRootPath()
-    // will return "hardware/interfaces".
-    std::string getPackageRootPath(const FQName &fqName) const;
-
-    // return getPackageRoot + ":" + getPackageRootPath
-    std::string getPackageRootOption(const FQName &fqName) const;
-
-    // Given an FQName of "android.hardware.nfc@1.0::INfc", return
-    // "android/hardware/".
-    std::string convertPackageRootToPath(const FQName &fqName) const;
+    status_t getPackageRoot(const FQName& fqName, std::string* root) const;
 
     status_t getPackageInterfaceFiles(
             const FQName &package,
@@ -96,6 +118,13 @@
             const FQName &package,
             std::vector<FQName> *packageInterfaces) const;
 
+    status_t isTypesOnlyPackage(const FQName& package, bool* result) const;
+
+    // Returns types which are imported/defined but not referenced in code
+    status_t addUnreferencedTypes(const std::vector<FQName>& packageInterfaces,
+                                  std::set<FQName>* unreferencedDefinitions,
+                                  std::set<FQName>* unreferencedImports) const;
+
     // Enforce a set of restrictions on a set of packages. These include:
     //    - minor version upgrades
     // "packages" contains names like "android.hardware.nfc@1.1".
@@ -103,19 +132,46 @@
     status_t enforceRestrictionsOnPackage(const FQName& fqName,
                                           Enforce enforcement = Enforce::FULL) const;
 
+private:
     static bool MakeParentHierarchy(const std::string &path);
 
-private:
-    // A list of top-level directories (mPackageRootPaths)
-    // corresponding to a list of package roots (mPackageRoots). For
-    // example, if mPackageRootPaths[0] == "hardware/interfaces" and
-    // mPackageRoots[0] == "android.hardware" this means that all
-    // packages starting with "android.hardware" will be looked up in
-    // "hardware/interfaces".
-    std::vector<std::string> mPackageRootPaths;
-    std::vector<std::string> mPackageRoots;
+    enum class HashStatus {
+        ERROR,
+        UNFROZEN,
+        FROZEN,
+        CHANGED,  // frozen but changed
+    };
+    HashStatus checkHash(const FQName& fqName) const;
+    status_t getUnfrozenDependencies(const FQName& fqName, std::set<FQName>* result) const;
 
-    std::string mRootPath;
+    // indicates that packages in "android.hardware" will be looked up in hardware/interfaces
+    struct PackageRoot {
+        std::string path; // e.x. hardware/interfaces
+        FQName root; // e.x. android.hardware@0.0
+    };
+
+    // nullptr if it doesn't exist
+    const PackageRoot* findPackageRoot(const FQName& fqName) const;
+
+    // Given package-root paths of ["hardware/interfaces",
+    // "vendor/<something>/interfaces"], package roots of
+    // ["android.hardware", "vendor.<something>.hardware"], and a
+    // FQName of "android.hardware.nfc@1.0::INfc, then getPackageRootPath()
+    // will return "hardware/interfaces".
+    status_t getPackageRootPath(const FQName& fqName, std::string* path) const;
+
+    // Given an FQName of "android.hardware.nfc@1.0::INfc", return
+    // "android/hardware/".
+    status_t convertPackageRootToPath(const FQName& fqName, std::string* path) const;
+
+    std::vector<PackageRoot> mPackageRoots;
+    std::string mRootPath;    // root of android source tree (to locate package roots)
+    std::string mOutputPath;  // root of output directory
+    std::string mDepFile;     // location to write depfile
+
+    // hidl-gen options
+    bool mVerbose = false;
+    std::string mOwner;
 
     // cache to parse().
     mutable std::map<FQName, AST *> mCache;
@@ -123,19 +179,14 @@
     // cache to enforceRestrictionsOnPackage().
     mutable std::set<FQName> mPackagesEnforced;
 
-    std::vector<std::string>::const_iterator findPackageRoot(
-            const FQName &fqName) const;
+    mutable std::set<std::string> mReadFiles;
 
-    // Returns abs package path by prepending the root path if a package
-    // path is non-absolute.
-    // If root is '/android/master' and getPackagePath returns 'h/i/nfc/V1_0'
-    // this will return '/android/master/h/i/nfc/V1_0'.
-    // If root is '/android/master' and getPackagePath returns '/abs/path/to/nfc/V1_0'
-    // this will return '/abs/path/to/nfc/V1_0'
-    std::string getAbsolutePackagePath(const FQName& fqName) const;
+    // Returns the given path if it is absolute, otherwise it returns
+    // the path relative to mRootPath
+    std::string makeAbsolute(const std::string& string) const;
 
     // Rules of enforceRestrictionsOnPackage are listed below.
-    status_t enforceMinorVersionUprevs(const FQName &fqName) const;
+    status_t enforceMinorVersionUprevs(const FQName& fqName, Enforce enforcement) const;
     status_t enforceHashes(const FQName &fqName) const;
 
     DISALLOW_COPY_AND_ASSIGN(Coordinator);
diff --git a/DeathRecipientType.cpp b/DeathRecipientType.cpp
index 828f217..abc69fc 100644
--- a/DeathRecipientType.cpp
+++ b/DeathRecipientType.cpp
@@ -21,7 +21,7 @@
 
 namespace android {
 
-DeathRecipientType::DeathRecipientType() {}
+DeathRecipientType::DeathRecipientType(Scope* parent) : Type(parent) {}
 
 std::string DeathRecipientType::typeName() const {
     return "death recipient";
@@ -74,17 +74,12 @@
     return true;
 }
 
-bool DeathRecipientType::isJavaCompatible() const {
-    return true;
-}
-
 void DeathRecipientType::getAlignmentAndSize(size_t *align, size_t *size) const {
     *align = *size = 0; // this object should only be used in passthrough mode
 }
 
-status_t DeathRecipientType::emitVtsTypeDeclarations(Formatter &out) const {
+void DeathRecipientType::emitVtsTypeDeclarations(Formatter& out) const {
     out << "type: " << getVtsType() << "\n";
-    return OK;
 }
 
 }  // namespace android
diff --git a/DeathRecipientType.h b/DeathRecipientType.h
index 386cec5..a7213cd 100644
--- a/DeathRecipientType.h
+++ b/DeathRecipientType.h
@@ -23,7 +23,7 @@
 namespace android {
 
 struct DeathRecipientType : public Type {
-    DeathRecipientType();
+    DeathRecipientType(Scope* parent);
 
     std::string getCppType(
             StorageMode mode,
@@ -45,11 +45,9 @@
     bool needsEmbeddedReadWrite() const override;
     bool resultNeedsDeref() const override;
 
-    bool isJavaCompatible() const override;
-
     void getAlignmentAndSize(size_t *align, size_t *size) const override;
 
-    status_t emitVtsTypeDeclarations(Formatter &out) const override;
+    void emitVtsTypeDeclarations(Formatter& out) const override;
 };
 
 }  // namespace android
diff --git a/DocComment.cpp b/DocComment.cpp
new file mode 100644
index 0000000..91bc676
--- /dev/null
+++ b/DocComment.cpp
@@ -0,0 +1,71 @@
+/*
+ * Copyright (C) 2018 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "DocComment.h"
+
+#include <hidl-util/StringHelper.h>
+
+#include <cctype>
+#include <sstream>
+
+namespace android {
+
+DocComment::DocComment(const std::string& comment) {
+    std::vector<std::string> lines;
+    StringHelper::SplitString(comment, '\n', &lines);
+
+    bool foundFirstLine = false;
+
+    std::ostringstream is;
+    for (size_t l = 0; l < lines.size(); l++) {
+        const std::string& line = lines[l];
+
+        // Delete prefixes like "    * ", "   *", or "    ".
+        size_t idx = 0;
+        for (; idx < line.size() && isspace(line[idx]); idx++)
+            ;
+        if (idx < line.size() && line[idx] == '*') idx++;
+        if (idx < line.size() && line[idx] == ' ') idx++;
+
+        if (idx < line.size()) {
+            foundFirstLine = true;
+        }
+
+        if (!foundFirstLine) continue;
+
+        is << line.substr(idx);
+
+        if (l + 1 < lines.size()) {
+            is << "\n";
+        }
+    }
+
+    mComment = is.str();
+}
+
+void DocComment::merge(const DocComment* comment) {
+    mComment = mComment + "\n\n" + comment->mComment;
+}
+
+void DocComment::emit(Formatter& out) const {
+    out << "/**\n";
+    out.setLinePrefix(" * ");
+    out << mComment;
+    out.unsetLinePrefix();
+    out << " */\n";
+}
+
+}  // namespace android
diff --git a/DocComment.h b/DocComment.h
new file mode 100644
index 0000000..e0677eb
--- /dev/null
+++ b/DocComment.h
@@ -0,0 +1,52 @@
+/*
+ * Copyright (C) 2018 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef DOC_COMMENT_H_
+
+#define DOC_COMMENT_H_
+
+#include <hidl-util/Formatter.h>
+
+#include <string>
+
+namespace android {
+
+struct DocComment {
+    DocComment(const std::string& comment);
+
+    void merge(const DocComment* comment);
+
+    void emit(Formatter& out) const;
+
+   private:
+    std::string mComment;
+};
+
+struct DocCommentable {
+    void setDocComment(const DocComment* docComment) { mDocComment = docComment; }
+    void emitDocComment(Formatter& out) const {
+        if (mDocComment != nullptr) {
+            mDocComment->emit(out);
+        }
+    }
+
+   private:
+    const DocComment* mDocComment = nullptr;
+};
+
+}  // namespace android
+
+#endif  // DOC_COMMENT_H_
diff --git a/EnumType.cpp b/EnumType.cpp
index fb8545f..ead64ba 100644
--- a/EnumType.cpp
+++ b/EnumType.cpp
@@ -16,46 +16,123 @@
 
 #include "EnumType.h"
 
-#include "Annotation.h"
-#include "ScalarType.h"
-
-#include <inttypes.h>
 #include <hidl-util/Formatter.h>
-#include <android-base/logging.h>
+#include <inttypes.h>
+#include <iostream>
+#include <unordered_map>
+
+#include "Annotation.h"
+#include "Location.h"
+#include "ScalarType.h"
 
 namespace android {
 
-EnumType::EnumType(const char* localName, const Location& location, Type* storageType,
-                   Scope* parent)
-    : Scope(localName, location, parent), mValues(), mStorageType(storageType) {
-    mBitfieldType = new BitFieldType();
-    mBitfieldType->setElementType(this);
-}
+EnumType::EnumType(const char* localName, const FQName& fullName, const Location& location,
+                   const Reference<Type>& storageType, Scope* parent)
+    : Scope(localName, fullName, location, parent), mValues(), mStorageType(storageType) {}
 
 const Type *EnumType::storageType() const {
-    return mStorageType;
+    return mStorageType.get();
 }
 
 const std::vector<EnumValue *> &EnumType::values() const {
     return mValues;
 }
 
-void EnumType::addValue(EnumValue *value) {
-    CHECK(value != nullptr);
+void EnumType::forEachValueFromRoot(const std::function<void(EnumValue*)> f) const {
+    std::vector<const EnumType*> chain = typeChain();
+    for (auto it = chain.rbegin(); it != chain.rend(); ++it) {
+        const auto& type = *it;
+        for (EnumValue* v : type->values()) {
+            f(v);
+        }
+    }
+}
 
-    EnumValue *prev = nullptr;
-    std::vector<const EnumType *> chain;
-    getTypeChain(&chain);
-    for (auto it = chain.begin(); it != chain.end(); ++it) {
-        const auto &type = *it;
-        if(!type->values().empty()) {
-            prev = type->values().back();
+void EnumType::addValue(EnumValue* value) {
+    CHECK(value != nullptr);
+    mValues.push_back(value);
+}
+
+status_t EnumType::resolveInheritance() {
+    const EnumType* prevType = nullptr;
+    EnumValue* prevValue = nullptr;
+
+    for (const auto* type : superTypeChain()) {
+        if (!type->values().empty()) {
+            prevType = type;
+            prevValue = type->values().back();
             break;
         }
     }
 
-    value->autofill(prev, resolveToScalarType());
-    mValues.push_back(value);
+    for (auto* value : mValues) {
+        value->autofill(prevType, prevValue, mStorageType->resolveToScalarType());
+        prevType = this;
+        prevValue = value;
+    }
+
+    return Scope::resolveInheritance();
+}
+
+std::vector<const Reference<Type>*> EnumType::getReferences() const {
+    return {&mStorageType};
+}
+
+std::vector<const ConstantExpression*> EnumType::getConstantExpressions() const {
+    std::vector<const ConstantExpression*> ret;
+    for (const auto* value : mValues) {
+        ret.push_back(value->constExpr());
+    }
+    return ret;
+}
+
+status_t EnumType::validate() const {
+    CHECK(getSubTypes().empty());
+
+    if (!isElidableType() || !mStorageType->isValidEnumStorageType()) {
+        std::cerr << "ERROR: Invalid enum storage type (" << (mStorageType)->typeName()
+                  << ") specified at " << mStorageType.location() << "\n";
+        return UNKNOWN_ERROR;
+    }
+
+    status_t err = validateUniqueNames();
+    if (err != OK) return err;
+
+    return Scope::validate();
+}
+
+status_t EnumType::validateUniqueNames() const {
+    std::unordered_map<std::string, const EnumType*> registeredValueNames;
+    for (const auto* type : superTypeChain()) {
+        for (const auto* enumValue : type->mValues) {
+            // No need to check super value uniqueness
+            registeredValueNames[enumValue->name()] = type;
+        }
+    }
+
+    for (const auto* value : mValues) {
+        auto registered = registeredValueNames.find(value->name());
+
+        if (registered != registeredValueNames.end()) {
+            const EnumType* definedInType = registered->second;
+
+            if (definedInType == this) {
+                // Defined in this enum
+                std::cerr << "ERROR: Redefinition of value '" << value->name() << "'";
+            } else {
+                // Defined in super enum
+                std::cerr << "ERROR: Redefinition of value '" << value->name()
+                          << "' defined in enum '" << definedInType->fullName() << "'";
+            }
+            std::cerr << " at " << value->location() << "\n";
+            return UNKNOWN_ERROR;
+        }
+
+        registeredValueNames[value->name()] = this;
+    }
+
+    return OK;
 }
 
 bool EnumType::isElidableType() const {
@@ -74,7 +151,7 @@
     return true;
 }
 
-bool EnumType::canCheckEquality() const {
+bool EnumType::deepCanCheckEquality(std::unordered_set<const Type*>* /* visited */) const {
     return true;
 }
 
@@ -99,13 +176,21 @@
     return "TYPE_ENUM";
 }
 
-BitFieldType *EnumType::getBitfieldType() const {
-    return mBitfieldType;
+std::string EnumType::getBitfieldCppType(StorageMode /* mode */, bool specifyNamespaces) const {
+    const std::string space = specifyNamespaces ? "::android::hardware::" : "";
+    return space + "hidl_bitfield<" + (specifyNamespaces ? fullName() : localName()) + ">";
+}
+
+std::string EnumType::getBitfieldJavaType(bool forInitializer) const {
+    return resolveToScalarType()->getJavaType(forInitializer);
+}
+
+std::string EnumType::getBitfieldJavaWrapperType() const {
+    return resolveToScalarType()->getJavaWrapperType();
 }
 
 LocalIdentifier *EnumType::lookupIdentifier(const std::string &name) const {
-    std::vector<const EnumType *> chain;
-    getTypeChain(&chain);
+    std::vector<const EnumType*> chain = typeChain();
     for (auto it = chain.begin(); it != chain.end(); ++it) {
         const auto &type = *it;
         for(EnumValue *v : type->values()) {
@@ -149,7 +234,7 @@
             out, depth, parcelName, blobName, fieldName, offset, isReader);
 }
 
-status_t EnumType::emitTypeDeclarations(Formatter &out) const {
+void EnumType::emitTypeDeclarations(Formatter& out) const {
     const ScalarType *scalarType = mStorageType->resolveToScalarType();
     CHECK(scalarType != nullptr);
 
@@ -163,13 +248,14 @@
 
     out.indent();
 
-    std::vector<const EnumType *> chain;
-    getTypeChain(&chain);
+    std::vector<const EnumType*> chain = typeChain();
 
     for (auto it = chain.rbegin(); it != chain.rend(); ++it) {
         const auto &type = *it;
 
         for (const auto &entry : type->values()) {
+            entry->emitDocComment(out);
+
             out << entry->name();
 
             std::string value = entry->cppValue(scalarType->getKind());
@@ -179,7 +265,7 @@
             out << ",";
 
             std::string comment = entry->comment();
-            if (!comment.empty() && comment != value) {
+            if (!comment.empty()) {
                 out << " // " << comment;
             }
 
@@ -189,8 +275,42 @@
 
     out.unindent();
     out << "};\n\n";
+}
 
-    return OK;
+void EnumType::emitTypeForwardDeclaration(Formatter& out) const {
+    const ScalarType* scalarType = mStorageType->resolveToScalarType();
+    const std::string storageType = scalarType->getCppStackType();
+
+    out << "enum class " << localName() << " : " << storageType << ";\n";
+}
+
+void EnumType::emitIteratorDeclaration(Formatter& out) const {
+    size_t elementCount = 0;
+    for (const auto* type : typeChain()) {
+        elementCount += type->mValues.size();
+    }
+
+    out << "template<> struct hidl_enum_iterator<" << getCppStackType() << ">\n";
+    out.block([&] {
+        out << "const " << getCppStackType() << "* begin() { return static_begin(); }\n";
+        out << "const " << getCppStackType() << "* end() { return begin() + " << elementCount
+            << "; }\n";
+        out << "private:\n";
+        out << "static const " << getCppStackType() << "* static_begin() ";
+        out.block([&] {
+            out << "static const " << getCppStackType() << " kVals[" << elementCount << "] ";
+            out.block([&] {
+                auto enumerators = typeChain();
+                std::reverse(enumerators.begin(), enumerators.end());
+                for (const auto* type : enumerators) {
+                    for (const auto* enumValue : type->mValues) {
+                        out << fullName() << "::" << enumValue->name() << ",\n";
+                    }
+                }
+            }) << ";\n";
+            out << "return &kVals[0];\n";
+        });
+    }) << ";\n\n";
 }
 
 void EnumType::emitEnumBitwiseOperator(
@@ -258,7 +378,17 @@
     out << "}\n\n";
 }
 
-status_t EnumType::emitGlobalTypeDeclarations(Formatter &out) const {
+void EnumType::emitGlobalTypeDeclarations(Formatter& out) const {
+    out << "namespace android {\n";
+    out << "namespace hardware {\n";
+
+    emitIteratorDeclaration(out);
+
+    out << "}  // namespace hardware\n";
+    out << "}  // namespace android\n";
+}
+
+void EnumType::emitPackageTypeDeclarations(Formatter& out) const {
     emitEnumBitwiseOperator(out, true  /* lhsIsEnum */, true  /* rhsIsEnum */, "|");
     emitEnumBitwiseOperator(out, false /* lhsIsEnum */, true  /* rhsIsEnum */, "|");
     emitEnumBitwiseOperator(out, true  /* lhsIsEnum */, false /* rhsIsEnum */, "|");
@@ -269,40 +399,22 @@
     emitBitFieldBitwiseAssignmentOperator(out, "|");
     emitBitFieldBitwiseAssignmentOperator(out, "&");
 
-    // toString for bitfields, equivalent to dumpBitfield in Java
-    out << "template<typename>\n"
-        << "std::string toString("
-        << resolveToScalarType()->getCppArgumentType()
-        << " o);\n";
-    out << "template<>\n"
-        << "std::string toString<" << getCppStackType() << ">("
-        << resolveToScalarType()->getCppArgumentType()
-        << " o);\n\n";
-
-    // toString for enum itself
-    out << "std::string toString("
-        << getCppArgumentType()
-        << " o);\n\n";
-
-    return OK;
-}
-
-status_t EnumType::emitTypeDefinitions(Formatter &out, const std::string /* prefix */) const {
-
     const ScalarType *scalarType = mStorageType->resolveToScalarType();
     CHECK(scalarType != NULL);
 
+    out << "template<typename>\n"
+        << "static inline std::string toString(" << resolveToScalarType()->getCppArgumentType()
+        << " o);\n";
     out << "template<>\n"
-        << "std::string toString<" << getCppStackType() << ">("
-        << scalarType->getCppArgumentType()
-        << " o) ";
+        << "inline std::string toString<" << getCppStackType() << ">("
+        << scalarType->getCppArgumentType() << " o) ";
     out.block([&] {
         // include toHexString for scalar types
         out << "using ::android::hardware::details::toHexString;\n"
             << "std::string os;\n"
-            << getBitfieldType()->getCppStackType() << " flipped = 0;\n"
+            << getBitfieldCppType(StorageMode_Stack) << " flipped = 0;\n"
             << "bool first = true;\n";
-        for (EnumValue *value : values()) {
+        forEachValueFromRoot([&](EnumValue* value) {
             std::string valueName = fullName() + "::" + value->name();
             out.sIf("(o & " + valueName + ")" +
                     " == static_cast<" + scalarType->getCppStackType() +
@@ -312,7 +424,7 @@
                     << "first = false;\n"
                     << "flipped |= " << valueName << ";\n";
             }).endl();
-        }
+        });
         // put remaining bits
         out.sIf("o != flipped", [&] {
             out << "os += (first ? \"\" : \" | \");\n";
@@ -325,27 +437,23 @@
         out << "return os;\n";
     }).endl().endl();
 
-    out << "std::string toString("
-        << getCppArgumentType()
-        << " o) ";
+    out << "static inline std::string toString(" << getCppArgumentType() << " o) ";
 
     out.block([&] {
         out << "using ::android::hardware::details::toHexString;\n";
-        for (EnumValue *value : values()) {
+        forEachValueFromRoot([&](EnumValue* value) {
             out.sIf("o == " + fullName() + "::" + value->name(), [&] {
                 out << "return \"" << value->name() << "\";\n";
             }).endl();
-        }
+        });
         out << "std::string os;\n";
         scalarType->emitHexDump(out, "os",
             "static_cast<" + scalarType->getCppStackType() + ">(o)");
         out << "return os;\n";
     }).endl().endl();
-
-    return OK;
 }
 
-status_t EnumType::emitJavaTypeDeclarations(Formatter &out, bool atTopLevel) const {
+void EnumType::emitJavaTypeDeclarations(Formatter& out, bool atTopLevel) const {
     const ScalarType *scalarType = mStorageType->resolveToScalarType();
     CHECK(scalarType != NULL);
 
@@ -360,13 +468,14 @@
     const std::string typeName =
         scalarType->getJavaType(false /* forInitializer */);
 
-    std::vector<const EnumType *> chain;
-    getTypeChain(&chain);
+    std::vector<const EnumType*> chain = typeChain();
 
     for (auto it = chain.rbegin(); it != chain.rend(); ++it) {
         const auto &type = *it;
 
         for (const auto &entry : type->values()) {
+            entry->emitDocComment(out);
+
             out << "public static final "
                 << typeName
                 << " "
@@ -381,7 +490,7 @@
             out << ";";
 
             std::string comment = entry->comment();
-            if (!comment.empty() && comment != value) {
+            if (!comment.empty()) {
                 out << " // " << comment;
             }
 
@@ -392,34 +501,34 @@
     out << "public static final String toString("
         << typeName << " o) ";
     out.block([&] {
-        for (EnumValue *value : values()) {
+        forEachValueFromRoot([&](EnumValue* value) {
             out.sIf("o == " + value->name(), [&] {
                 out << "return \"" << value->name() << "\";\n";
             }).endl();
-        }
+        });
         out << "return \"0x\" + ";
         scalarType->emitConvertToJavaHexString(out, "o");
         out << ";\n";
     }).endl();
 
-    auto bitfieldType = getBitfieldType()->getJavaType(false /* forInitializer */);
-    auto bitfieldWrapperType = getBitfieldType()->getJavaWrapperType();
+    auto bitfieldType = getBitfieldJavaType(false /* forInitializer */);
+    auto bitfieldWrapperType = getBitfieldJavaWrapperType();
     out << "\n"
         << "public static final String dumpBitfield("
         << bitfieldType << " o) ";
     out.block([&] {
         out << "java.util.ArrayList<String> list = new java.util.ArrayList<>();\n";
         out << bitfieldType << " flipped = 0;\n";
-        for (EnumValue *value : values()) {
+        forEachValueFromRoot([&](EnumValue* value) {
             if (value->constExpr()->castSizeT() == 0) {
                 out << "list.add(\"" << value->name() << "\"); // " << value->name() << " == 0\n";
-                continue;
+                return;  // continue to next value
             }
             out.sIf("(o & " + value->name() + ") == " + value->name(), [&] {
                 out << "list.add(\"" << value->name() << "\");\n";
                 out << "flipped |= " << value->name() << ";\n";
             }).endl();
-        }
+        });
         // put remaining bits
         out.sIf("o != flipped", [&] {
             out << "list.add(\"0x\" + ";
@@ -431,11 +540,9 @@
 
     out.unindent();
     out << "};\n\n";
-
-    return OK;
 }
 
-status_t EnumType::emitVtsTypeDeclarations(Formatter &out) const {
+void EnumType::emitVtsTypeDeclarations(Formatter& out) const {
     const ScalarType *scalarType = mStorageType->resolveToScalarType();
 
     out << "name: \"" << fullName() << "\"\n";
@@ -446,8 +553,7 @@
     out << "scalar_type: \""
         << scalarType->getVtsScalarType()
         << "\"\n\n";
-    std::vector<const EnumType *> chain;
-    getTypeChain(&chain);
+    std::vector<const EnumType*> chain = typeChain();
 
     for (auto it = chain.rbegin(); it != chain.rend(); ++it) {
         const auto &type = *it;
@@ -470,13 +576,11 @@
 
     out.unindent();
     out << "}\n";
-    return OK;
 }
 
-status_t EnumType::emitVtsAttributeType(Formatter &out) const {
+void EnumType::emitVtsAttributeType(Formatter& out) const {
     out << "type: " << getVtsType() << "\n";
     out << "predefined_type: \"" << fullName() << "\"\n";
-    return OK;
 }
 
 void EnumType::emitJavaDump(
@@ -487,19 +591,28 @@
         << name << "));\n";
 }
 
-void EnumType::getTypeChain(std::vector<const EnumType *> *out) const {
-    out->clear();
-    const EnumType *type = this;
-    for (;;) {
-        out->push_back(type);
+std::vector<const EnumType*> EnumType::typeChain() const {
+    std::vector<const EnumType*> types;
+    for (const EnumType* type = this; type != nullptr;) {
+        types.push_back(type);
 
-        const Type *superType = type->storageType();
-        if (superType == NULL || !superType->isEnum()) {
-            break;
+        const Type* superType = type->storageType();
+        if (superType != nullptr && superType->isEnum()) {
+            type = static_cast<const EnumType*>(superType);
+        } else {
+            type = nullptr;
         }
-
-        type = static_cast<const EnumType *>(superType);
     }
+
+    return types;
+}
+
+std::vector<const EnumType*> EnumType::superTypeChain() const {
+    const Type* superType = storageType();
+    if (superType == nullptr || !superType->isEnum()) {
+        return {};
+    }
+    return static_cast<const EnumType*>(superType)->typeChain();
 }
 
 void EnumType::getAlignmentAndSize(size_t *align, size_t *size) const {
@@ -523,7 +636,7 @@
     }
 }
 
-status_t EnumType::emitExportedHeader(Formatter &out, bool forJava) const {
+void EnumType::emitExportedHeader(Formatter& out, bool forJava) const {
     const Annotation *annotation = findExportAnnotation();
     CHECK(annotation != nullptr);
 
@@ -557,7 +670,7 @@
 
     std::vector<const EnumType *> chain;
     if (exportParent) {
-        getTypeChain(&chain);
+        chain = typeChain();
     } else {
         chain = { this };
     }
@@ -596,7 +709,7 @@
                 out << ";";
 
                 std::string comment = entry->comment();
-                if (!comment.empty() && comment != value) {
+                if (!comment.empty()) {
                     out << " // " << comment;
                 }
 
@@ -610,7 +723,7 @@
         }
         out << "\n";
 
-        return OK;
+        return;
     }
 
     if (!name.empty()) {
@@ -634,7 +747,7 @@
             out << ",";
 
             std::string comment = entry->comment();
-            if (!comment.empty() && comment != value) {
+            if (!comment.empty()) {
                 out << " // " << comment;
             }
 
@@ -650,17 +763,12 @@
     }
 
     out << ";\n\n";
-
-    return OK;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 
-EnumValue::EnumValue(const char *name, ConstantExpression *value)
-    : mName(name),
-      mValue(value),
-      mIsAutoFill(false) {
-}
+EnumValue::EnumValue(const char* name, ConstantExpression* value, const Location& location)
+    : mName(name), mValue(value), mLocation(location), mIsAutoFill(false) {}
 
 std::string EnumValue::name() const {
     return mName;
@@ -682,6 +790,7 @@
 
 std::string EnumValue::comment() const {
     CHECK(mValue != nullptr);
+    if (mValue->descriptionIsTrivial()) return "";
     return mValue->description();
 }
 
@@ -690,18 +799,21 @@
     return mValue;
 }
 
-void EnumValue::autofill(const EnumValue *prev, const ScalarType *type) {
-    if(mValue != nullptr)
-        return;
+void EnumValue::autofill(const EnumType* prevType, EnumValue* prevValue, const ScalarType* type) {
+    // Value is defined explicitly
+    if (mValue != nullptr) return;
+
+    CHECK((prevType == nullptr) == (prevValue == nullptr));
+
     mIsAutoFill = true;
-    ConstantExpression *value = new ConstantExpression();
-    if(prev == nullptr) {
-        *value = ConstantExpression::Zero(type->getKind());
+    if (prevValue == nullptr) {
+        mValue = ConstantExpression::Zero(type->getKind()).release();
     } else {
-        CHECK(prev->mValue != nullptr);
-        *value = prev->mValue->addOne();
+        std::string description = prevType->fullName() + "." + prevValue->name() + " implicitly";
+        auto* prevReference = new ReferenceConstantExpression(
+            Reference<LocalIdentifier>(prevValue, mLocation), description);
+        mValue = prevReference->addOne(type->getKind()).release();
     }
-    mValue = value;
 }
 
 bool EnumValue::isAutoFill() const {
@@ -712,17 +824,28 @@
     return true;
 }
 
+const Location& EnumValue::location() const {
+    return mLocation;
+}
+
 ////////////////////////////////////////////////////////////////////////////////
 
+BitFieldType::BitFieldType(Scope* parent) : TemplatedType(parent) {}
+
 bool BitFieldType::isBitField() const {
     return true;
 }
 
-std::string BitFieldType::typeName() const {
-    return "mask" + (mElementType == nullptr ? "" : (" of " + mElementType->typeName()));
+const EnumType* BitFieldType::getElementEnumType() const {
+    CHECK(mElementType.get() != nullptr && mElementType->isEnum());
+    return static_cast<const EnumType*>(mElementType.get());
 }
 
-bool BitFieldType::isCompatibleElementType(Type *elementType) const {
+std::string BitFieldType::templatedTypeName() const {
+    return "mask";
+}
+
+bool BitFieldType::isCompatibleElementType(const Type* elementType) const {
     return elementType->isEnum();
 }
 
@@ -732,11 +855,11 @@
 
 std::string BitFieldType::getCppType(StorageMode mode,
                                  bool specifyNamespaces) const {
-    return resolveToScalarType()->getCppType(mode, specifyNamespaces);
+    return getElementEnumType()->getBitfieldCppType(mode, specifyNamespaces);
 }
 
 std::string BitFieldType::getJavaType(bool forInitializer) const {
-    return resolveToScalarType()->getJavaType(forInitializer);
+    return getElementEnumType()->getBitfieldJavaType(forInitializer);
 }
 
 std::string BitFieldType::getJavaSuffix() const {
@@ -744,7 +867,7 @@
 }
 
 std::string BitFieldType::getJavaWrapperType() const {
-    return resolveToScalarType()->getJavaWrapperType();
+    return getElementEnumType()->getBitfieldJavaWrapperType();
 }
 
 std::string BitFieldType::getVtsType() const {
@@ -755,18 +878,17 @@
     return resolveToScalarType()->isElidableType();
 }
 
-bool BitFieldType::canCheckEquality() const {
-    return resolveToScalarType()->canCheckEquality();
+bool BitFieldType::deepCanCheckEquality(std::unordered_set<const Type*>* visited) const {
+    return resolveToScalarType()->canCheckEquality(visited);
 }
 
-status_t BitFieldType::emitVtsAttributeType(Formatter &out) const {
+void BitFieldType::emitVtsAttributeType(Formatter& out) const {
     out << "type: " << getVtsType() << "\n";
     out << "scalar_type: \""
         << mElementType->resolveToScalarType()->getVtsScalarType()
         << "\"\n";
-    out << "predefined_type: \""
-        << static_cast<NamedType *>(mElementType)->fullName() << "\"\n";
-    return OK;
+    out << "predefined_type: \"" << static_cast<const NamedType*>(mElementType.get())->fullName()
+        << "\"\n";
 }
 
 void BitFieldType::getAlignmentAndSize(size_t *align, size_t *size) const {
@@ -790,9 +912,9 @@
             true /* needsCast */);
 }
 
-EnumType *BitFieldType::getEnumType() const {
+const EnumType* BitFieldType::getEnumType() const {
     CHECK(mElementType->isEnum());
-    return static_cast<EnumType *>(mElementType);
+    return static_cast<const EnumType*>(mElementType.get());
 }
 
 // a bitfield maps to the underlying scalar type in C++, so operator<< is
diff --git a/EnumType.h b/EnumType.h
index d829292..eef4eb2 100644
--- a/EnumType.h
+++ b/EnumType.h
@@ -19,6 +19,7 @@
 #define ENUM_TYPE_H_
 
 #include "ConstantExpression.h"
+#include "Reference.h"
 #include "Scope.h"
 
 #include <vector>
@@ -29,12 +30,15 @@
 struct BitFieldType;
 
 struct EnumType : public Scope {
-    EnumType(const char* localName, const Location& location, Type* storageType, Scope* parent);
+    EnumType(const char* localName, const FQName& fullName, const Location& location,
+             const Reference<Type>& storageType, Scope* parent);
 
     const Type *storageType() const;
     const std::vector<EnumValue *> &values() const;
     void addValue(EnumValue *value);
 
+    void forEachValueFromRoot(const std::function<void(EnumValue*)> f) const;
+
     LocalIdentifier *lookupIdentifier(const std::string &name) const override;
 
     bool isElidableType() const override;
@@ -42,7 +46,7 @@
 
     std::string typeName() const override;
     bool isEnum() const override;
-    bool canCheckEquality() const override;
+    bool deepCanCheckEquality(std::unordered_set<const Type*>* visited) const override;
 
     std::string getCppType(StorageMode mode,
                            bool specifyNamespaces) const override;
@@ -55,8 +59,19 @@
 
     std::string getVtsType() const override;
 
+    std::string getBitfieldCppType(StorageMode mode, bool specifyNamespaces = true) const;
+    std::string getBitfieldJavaType(bool forInitializer = false) const;
+    std::string getBitfieldJavaWrapperType() const;
+
     // Return the type that corresponds to bitfield<T>.
-    BitFieldType *getBitfieldType() const;
+    const BitFieldType* getBitfieldType() const;
+
+    std::vector<const Reference<Type>*> getReferences() const override;
+    std::vector<const ConstantExpression*> getConstantExpressions() const override;
+
+    status_t resolveInheritance() override;
+    status_t validate() const override;
+    status_t validateUniqueNames() const;
 
     void emitReaderWriter(
             Formatter &out,
@@ -75,15 +90,15 @@
             const std::string &offset,
             bool isReader) const override;
 
-    status_t emitTypeDeclarations(Formatter &out) const override;
-    status_t emitGlobalTypeDeclarations(Formatter &out) const override;
-    status_t emitTypeDefinitions(Formatter &out, const std::string prefix) const override;
+    void emitTypeDeclarations(Formatter& out) const override;
+    void emitTypeForwardDeclaration(Formatter& out) const override;
+    void emitGlobalTypeDeclarations(Formatter& out) const override;
+    void emitPackageTypeDeclarations(Formatter& out) const override;
 
-    status_t emitJavaTypeDeclarations(
-            Formatter &out, bool atTopLevel) const override;
+    void emitJavaTypeDeclarations(Formatter& out, bool atTopLevel) const override;
 
-    status_t emitVtsTypeDeclarations(Formatter &out) const override;
-    status_t emitVtsAttributeType(Formatter &out) const override;
+    void emitVtsTypeDeclarations(Formatter& out) const override;
+    void emitVtsAttributeType(Formatter& out) const override;
 
     void emitJavaDump(
             Formatter &out,
@@ -95,12 +110,17 @@
     void appendToExportedTypesVector(
             std::vector<const Type *> *exportedTypes) const override;
 
-    status_t emitExportedHeader(Formatter &out, bool forJava) const override;
+    void emitExportedHeader(Formatter& out, bool forJava) const override;
 
-private:
-    void getTypeChain(std::vector<const EnumType *> *out) const;
+   private:
+    std::vector<const EnumType*> typeChain() const;
+    std::vector<const EnumType*> superTypeChain() const;
+
     const Annotation *findExportAnnotation() const;
 
+    void emitIteratorDeclaration(Formatter& out) const;
+    void emitIteratorDefinitions(Formatter& out) const;
+
     void emitEnumBitwiseOperator(
             Formatter &out,
             bool lhsIsEnum,
@@ -112,45 +132,50 @@
             const std::string &op) const;
 
     std::vector<EnumValue *> mValues;
-    Type *mStorageType;
-    BitFieldType *mBitfieldType;
+    Reference<Type> mStorageType;
 
     DISALLOW_COPY_AND_ASSIGN(EnumType);
 };
 
-struct EnumValue : public LocalIdentifier {
-    EnumValue(const char *name, ConstantExpression *value = nullptr);
+struct EnumValue : public LocalIdentifier, DocCommentable {
+    EnumValue(const char* name, ConstantExpression* value, const Location& location);
 
     std::string name() const;
     std::string value(ScalarType::Kind castKind) const;
     std::string cppValue(ScalarType::Kind castKind) const;
     std::string javaValue(ScalarType::Kind castKind) const;
     std::string comment() const;
-    void autofill(const EnumValue *prev, const ScalarType *type);
-    ConstantExpression *constExpr() const;
+    void autofill(const EnumType* prevType, EnumValue* prevValue, const ScalarType* type);
+    ConstantExpression* constExpr() const override;
 
     bool isAutoFill() const;
     bool isEnumValue() const override;
 
+    const Location& location() const;
 
+   private:
     std::string mName;
-    ConstantExpression *mValue;
+    ConstantExpression* mValue;
+    const Location mLocation;
     bool mIsAutoFill;
 
     DISALLOW_COPY_AND_ASSIGN(EnumValue);
 };
 
 struct BitFieldType : public TemplatedType {
+    BitFieldType(Scope* parent);
 
-    std::string typeName() const override;
+    std::string templatedTypeName() const override;
+
+    const EnumType* getElementEnumType() const;
 
     bool isBitField() const override;
 
-    bool isCompatibleElementType(Type *elementType) const override;
+    bool isCompatibleElementType(const Type* elementType) const override;
 
     bool isElidableType() const override;
 
-    bool canCheckEquality() const override;
+    bool deepCanCheckEquality(std::unordered_set<const Type*>* visited) const override;
 
     const ScalarType *resolveToScalarType() const override;
 
@@ -165,9 +190,9 @@
 
     std::string getVtsType() const override;
 
-    EnumType *getEnumType() const;
+    const EnumType* getEnumType() const;
 
-    status_t emitVtsAttributeType(Formatter &out) const override;
+    void emitVtsAttributeType(Formatter& out) const override;
 
     void getAlignmentAndSize(size_t *align, size_t *size) const override;
 
diff --git a/FmqType.cpp b/FmqType.cpp
index ec32bd0..f5eaaa6 100644
--- a/FmqType.cpp
+++ b/FmqType.cpp
@@ -23,12 +23,11 @@
 
 namespace android {
 
-FmqType::FmqType(const char *nsp, const char *name)
-    : mNamespace(nsp), mName(name) {
-}
+FmqType::FmqType(const char* nsp, const char* name, Scope* parent)
+    : TemplatedType(parent), mNamespace(nsp), mName(name) {}
 
-std::string FmqType::typeName() const {
-    return mName + " of " + mElementType->typeName();
+std::string FmqType::templatedTypeName() const {
+    return mName;
 }
 
 std::string FmqType::fullName() const {
@@ -138,7 +137,7 @@
             mNamespace);
 }
 
-bool FmqType::isJavaCompatible() const {
+bool FmqType::deepIsJavaCompatible(std::unordered_set<const Type*>* /* visited */) const {
     return false;
 }
 
@@ -160,7 +159,7 @@
     return true;
 }
 
-bool FmqType::isCompatibleElementType(Type *elementType) const {
+bool FmqType::isCompatibleElementType(const Type* elementType) const {
     return (!elementType->isInterface() && !elementType->needsEmbeddedReadWrite());
 }
 
@@ -169,9 +168,9 @@
         return "TYPE_FMQ_SYNC";
     } else if (mName == "MQDescriptorUnsync") {
         return "TYPE_FMQ_UNSYNC";
-    } else {
-        LOG(ERROR) << "Invalid fmq type name.\n";
     }
+
+    CHECK(false) << "Invalid FmqType.";
     return "";
 }
 
diff --git a/FmqType.h b/FmqType.h
index ef2b216..77ca150 100644
--- a/FmqType.h
+++ b/FmqType.h
@@ -23,11 +23,11 @@
 namespace android {
 
 struct FmqType : public TemplatedType {
-    FmqType(const char *nsp, const char *name);
+    FmqType(const char* nsp, const char* name, Scope* parent);
 
     std::string fullName() const;
 
-    std::string typeName() const;
+    std::string templatedTypeName() const;
 
     std::string getCppType(
             StorageMode mode,
@@ -54,13 +54,13 @@
             const std::string &parentName,
             const std::string &offsetText) const override;
 
-    bool isJavaCompatible() const override;
+    bool deepIsJavaCompatible(std::unordered_set<const Type*>* visited) const override;
 
     void getAlignmentAndSize(size_t *align, size_t *size) const override;
 
     bool needsEmbeddedReadWrite() const override;
     bool resultNeedsDeref() const override;
-    bool isCompatibleElementType(Type *elementType) const override;
+    bool isCompatibleElementType(const Type* elementType) const override;
 
     std::string getVtsType() const override;
     std::string getVtsValueName() const override;
diff --git a/HandleType.cpp b/HandleType.cpp
index 0e198f6..7b6545d 100644
--- a/HandleType.cpp
+++ b/HandleType.cpp
@@ -23,7 +23,7 @@
 
 namespace android {
 
-HandleType::HandleType() {}
+HandleType::HandleType(Scope* parent) : Type(parent) {}
 
 bool HandleType::isHandle() const {
     return true;
@@ -157,7 +157,7 @@
     return true;
 }
 
-bool HandleType::isJavaCompatible() const {
+bool HandleType::deepIsJavaCompatible(std::unordered_set<const Type*>* /* visited */) const {
     return false;
 }
 
@@ -167,9 +167,8 @@
     *size = assertion.size();
 }
 
-status_t HandleType::emitVtsTypeDeclarations(Formatter &out) const {
+void HandleType::emitVtsTypeDeclarations(Formatter& out) const {
     out << "type: " << getVtsType() << "\n";
-    return OK;
 }
 
 }  // namespace android
diff --git a/HandleType.h b/HandleType.h
index ad1f681..feaddb0 100644
--- a/HandleType.h
+++ b/HandleType.h
@@ -23,7 +23,7 @@
 namespace android {
 
 struct HandleType : public Type {
-    HandleType();
+    HandleType(Scope* parent);
 
     bool isHandle() const override;
 
@@ -58,13 +58,13 @@
 
     bool needsEmbeddedReadWrite() const override;
 
-    bool isJavaCompatible() const override;
+    bool deepIsJavaCompatible(std::unordered_set<const Type*>* visited) const override;
 
     bool useNameInEmitReaderWriterEmbedded(bool isReader) const override;
 
     void getAlignmentAndSize(size_t *align, size_t *size) const override;
 
-    status_t emitVtsTypeDeclarations(Formatter &out) const override;
+    void emitVtsTypeDeclarations(Formatter& out) const override;
 };
 
 }  // namespace android
diff --git a/Hash.cpp b/Hash.cpp
index 032227f..7eb315b 100644
--- a/Hash.cpp
+++ b/Hash.cpp
@@ -16,6 +16,7 @@
 
 #include "Hash.h"
 
+#include <algorithm>
 #include <fstream>
 #include <iomanip>
 #include <map>
@@ -27,7 +28,9 @@
 
 namespace android {
 
-const Hash &Hash::getHash(const std::string &path) {
+const std::vector<uint8_t> Hash::kEmptyHash = std::vector<uint8_t>(SHA256_DIGEST_LENGTH, 0);
+
+Hash& Hash::getMutableHash(const std::string& path) {
     static std::map<std::string, Hash> hashes;
 
     auto it = hashes.find(path);
@@ -39,6 +42,14 @@
     return it->second;
 }
 
+const Hash& Hash::getHash(const std::string& path) {
+    return getMutableHash(path);
+}
+
+void Hash::clearHash(const std::string& path) {
+    getMutableHash(path).mHash = kEmptyHash;
+}
+
 static std::vector<uint8_t> sha256File(const std::string &path) {
     std::ifstream stream(path);
     std::stringstream fileStream;
@@ -156,16 +167,18 @@
     std::map<std::string,std::vector<std::string>> hashes;
 };
 
-std::vector<std::string> Hash::lookupHash(const std::string &path,
-                                          const std::string &interfaceName,
-                                          std::string *err) {
+std::vector<std::string> Hash::lookupHash(const std::string& path, const std::string& interfaceName,
+                                          std::string* err, bool* fileExists) {
     *err = "";
     const HashFile *file = HashFile::parse(path, err);
 
     if (file == nullptr || err->size() > 0) {
+        if (fileExists != nullptr) *fileExists = false;
         return {};
     }
 
+    if (fileExists != nullptr) *fileExists = true;
+
     return file->lookup(interfaceName);
 }
 
diff --git a/Interface.cpp b/Interface.cpp
index 243d103..1c66b31 100644
--- a/Interface.cpp
+++ b/Interface.cpp
@@ -28,10 +28,11 @@
 #include <unistd.h>
 
 #include <iostream>
+#include <memory>
 #include <sstream>
+#include <unordered_map>
 
 #include <android-base/logging.h>
-#include <hidl-hash/Hash.h>
 #include <hidl-util/Formatter.h>
 #include <hidl-util/StringHelper.h>
 
@@ -67,14 +68,18 @@
     LAST_HIDL_TRANSACTION   = 0x0fffffff,
 };
 
-Interface::Interface(const char* localName, const Location& location, Scope* parent,
-                     Interface* super)
-    : Scope(localName, location, parent), mSuperType(super), mIsJavaCompatibleInProgress(false) {}
+Interface::Interface(const char* localName, const FQName& fullName, const Location& location,
+                     Scope* parent, const Reference<Type>& superType, const Hash* fileHash)
+    : Scope(localName, fullName, location, parent), mSuperType(superType), mFileHash(fileHash) {}
 
 std::string Interface::typeName() const {
     return "interface " + localName();
 }
 
+const Hash* Interface::getFileHash() const {
+    return mFileHash;
+}
+
 bool Interface::fillPingMethod(Method *method) const {
     if (method->name() != "ping") {
         return false;
@@ -100,7 +105,6 @@
                     out << "return;\n";
                 }
             },
-            {IMPL_STUB, nullptr /* don't generate code */}
         } /*javaImpl*/
     );
 
@@ -211,7 +215,7 @@
                 out << "return ::android::hardware::Void();";
             } } }, /*cppImpl */
             { { IMPL_INTERFACE, [](auto &out) { /* javaImpl */
-                out << "android.os.SystemProperties.reportSyspropChanged();";
+                out << "android.os.HwBinder.enableInstrumentation();";
             } } } /*javaImpl */
     );
     return true;
@@ -284,22 +288,21 @@
     return true;
 }
 
-static void emitDigestChain(
-        Formatter &out,
-        const std::string &prefix,
-        const std::vector<const Interface *> &chain,
-        std::function<std::string(const ConstantExpression &)> byteToString) {
-    out.join(chain.begin(), chain.end(), ",\n", [&] (const auto &iface) {
-        const Hash &hash = Hash::getHash(iface->location().begin().filename());
+void Interface::emitDigestChain(
+    Formatter& out, const std::string& prefix, const std::vector<const Interface*>& chain,
+    std::function<std::string(std::unique_ptr<ConstantExpression>)> byteToString) const {
+    out.join(chain.begin(), chain.end(), ",\n", [&](const auto& iface) {
         out << prefix;
         out << "{";
-        out.join(hash.raw().begin(), hash.raw().end(), ",", [&](const auto &e) {
-            // Use ConstantExpression::cppValue / javaValue
-            // because Java used signed byte for uint8_t.
-            out << byteToString(ConstantExpression::ValueOf(ScalarType::Kind::KIND_UINT8, e));
-        });
+        out.join(
+            iface->getFileHash()->raw().begin(), iface->getFileHash()->raw().end(), ",",
+            [&](const auto& e) {
+                // Use ConstantExpression::cppValue / javaValue
+                // because Java used signed byte for uint8_t.
+                out << byteToString(ConstantExpression::ValueOf(ScalarType::Kind::KIND_UINT8, e));
+            });
         out << "} /* ";
-        out << hash.hexString();
+        out << iface->getFileHash()->hexString();
         out << " */";
     });
 }
@@ -317,8 +320,8 @@
             std::vector<const Interface *> chain = typeChain();
             out << "_hidl_cb(";
             out.block([&] {
-                emitDigestChain(out, "(" + digestType->getInternalDataCppType() + ")",
-                    chain, [](const auto &e){return e.cppValue();});
+                emitDigestChain(out, "(" + digestType->getInternalDataCppType() + ")", chain,
+                                [](const auto& e) { return e->cppValue(); });
             });
             out << ");\n";
             out << "return ::android::hardware::Void();\n";
@@ -331,7 +334,7 @@
             out.indent(2, [&] {
                 // No need for dimensions when elements are explicitly provided.
                 emitDigestChain(out, "new " + digestType->getJavaType(false /* forInitializer */),
-                    chain, [](const auto &e){return e.javaValue();});
+                                chain, [](const auto& e) { return e->javaValue(); });
             });
             out << "));\n";
         } } } /* javaImpl */
@@ -390,8 +393,7 @@
             {IMPL_STUB_IMPL,
                 [](auto &out) {
                     out << "::android::hidl::base::V1_0::DebugInfo info = {};\n";
-                    out << "info.pid = ::android::hardware::details::debuggable()"
-                        << "? getpid() : -1 /* pid */,\n";
+                    out << "info.pid = ::android::hardware::details::getPidIfSharable();\n";
                     out << "info.ptr = ::android::hardware::details::debuggable()"
                         << "? reinterpret_cast<uint64_t>(this) : 0;\n";
                     out << "info.arch = \n" << sArch << ";\n";
@@ -404,10 +406,9 @@
             const Type &refInfo = method->results().front()->type();
             out << refInfo.getJavaType(false /* forInitializer */) << " info = new "
                 << refInfo.getJavaType(true /* forInitializer */) << "();\n"
-                // TODO(b/34777099): PID for java.
-                << "info.pid = -1;\n"
+                << "info.pid = android.os.HidlSupport.getPidIfSharable();\n"
                 << "info.ptr = 0;\n"
-                << "info.arch = android.hidl.base.V1_0.DebugInfo.Architecture.UNKNOWN;"
+                << "info.arch = android.hidl.base.V1_0.DebugInfo.Architecture.UNKNOWN;\n"
                 << "return info;";
         } } } /* javaImpl */
     );
@@ -444,8 +445,8 @@
 bool Interface::addMethod(Method *method) {
     if (isIBase()) {
         if (!gAllReservedMethods.emplace(method->name(), method).second) {
-            LOG(ERROR) << "ERROR: hidl-gen encountered duplicated reserved method "
-                       << method->name();
+            std::cerr << "ERROR: hidl-gen encountered duplicated reserved method " << method->name()
+                      << std::endl;
             return false;
         }
         // will add it in addAllReservedMethods
@@ -453,28 +454,151 @@
     }
 
     CHECK(!method->isHidlReserved());
-    if (lookupMethod(method->name()) != nullptr) {
-        LOG(ERROR) << "Redefinition of method " << method->name();
-        return false;
-    }
-    size_t serial = FIRST_CALL_TRANSACTION;
-
-    serial += userDefinedMethods().size();
-
-    const Interface *ancestor = mSuperType;
-    while (ancestor != nullptr) {
-        serial += ancestor->userDefinedMethods().size();
-        ancestor = ancestor->superType();
-    }
-
-    CHECK(serial <= LAST_CALL_TRANSACTION) << "More than "
-            << LAST_CALL_TRANSACTION << " methods are not allowed.";
-    method->setSerialId(serial);
     mUserMethods.push_back(method);
 
     return true;
 }
 
+std::vector<const Reference<Type>*> Interface::getReferences() const {
+    std::vector<const Reference<Type>*> ret;
+
+    if (!isIBase()) {
+        ret.push_back(&mSuperType);
+    }
+
+    for (const auto* method : methods()) {
+        const auto& references = method->getReferences();
+        ret.insert(ret.end(), references.begin(), references.end());
+    }
+
+    return ret;
+}
+
+std::vector<const ConstantExpression*> Interface::getConstantExpressions() const {
+    std::vector<const ConstantExpression*> ret;
+    for (const auto* method : methods()) {
+        const auto& retMethod = method->getConstantExpressions();
+        ret.insert(ret.end(), retMethod.begin(), retMethod.end());
+    }
+    return ret;
+}
+
+std::vector<const Reference<Type>*> Interface::getStrongReferences() const {
+    // Interface is a special case as a reference:
+    // its definiton must be completed for extension but
+    // not necessary for other references.
+
+    std::vector<const Reference<Type>*> ret;
+    if (!isIBase()) {
+        ret.push_back(&mSuperType);
+    }
+
+    for (const auto* method : methods()) {
+        const auto& references = method->getStrongReferences();
+        ret.insert(ret.end(), references.begin(), references.end());
+    }
+
+    return ret;
+}
+
+status_t Interface::resolveInheritance() {
+    size_t serial = FIRST_CALL_TRANSACTION;
+    for (const auto* ancestor : superTypeChain()) {
+        serial += ancestor->mUserMethods.size();
+    }
+
+    for (Method* method : mUserMethods) {
+        if (serial > LAST_CALL_TRANSACTION) {
+            std::cerr << "ERROR: More than " << LAST_CALL_TRANSACTION
+                      << " methods (including super and reserved) are not allowed at " << location()
+                      << std::endl;
+            return UNKNOWN_ERROR;
+        }
+
+        method->setSerialId(serial);
+        serial++;
+    }
+
+    return Scope::resolveInheritance();
+}
+
+status_t Interface::validate() const {
+    CHECK(isIBase() == mSuperType.isEmptyReference());
+
+    if (!isIBase() && !mSuperType->isInterface()) {
+        std::cerr << "ERROR: You can only extend interfaces at " << mSuperType.location()
+                  << std::endl;
+        return UNKNOWN_ERROR;
+    }
+
+    status_t err;
+
+    err = validateUniqueNames();
+    if (err != OK) return err;
+
+    err = validateAnnotations();
+    if (err != OK) return err;
+
+    return Scope::validate();
+}
+
+void Interface::getAlignmentAndSize(size_t* align, size_t* size) const {
+    *align = 8;
+    *size = 8;
+}
+
+status_t Interface::validateUniqueNames() const {
+    std::unordered_map<std::string, const Interface*> registeredMethodNames;
+    for (auto const& tuple : allSuperMethodsFromRoot()) {
+        // No need to check super method uniqueness
+        registeredMethodNames[tuple.method()->name()] = tuple.interface();
+    }
+
+    for (const Method* method : mUserMethods) {
+        auto registered = registeredMethodNames.find(method->name());
+
+        if (registered != registeredMethodNames.end()) {
+            const Interface* definedInType = registered->second;
+
+            if (definedInType == this) {
+                // Defined in this interface
+                std::cerr << "ERROR: Redefinition of method '" << method->name() << "'";
+            } else if (definedInType->isIBase()) {
+                // Defined in IBase
+                std::cerr << "ERROR: Redefinition of reserved method '" << method->name() << "'";
+            } else {
+                // Defined in super not IBase
+                std::cerr << "ERROR: Redefinition of method '" << method->name()
+                          << "' defined in interface '" << definedInType->fullName() << "'";
+            }
+            std::cerr << " at " << method->location() << std::endl;
+            return UNKNOWN_ERROR;
+        }
+
+        registeredMethodNames[method->name()] = this;
+    }
+
+    return OK;
+}
+
+status_t Interface::validateAnnotations() const {
+    for (const Method* method : methods()) {
+        for (const Annotation* annotation : method->annotations()) {
+            const std::string name = annotation->name();
+
+            if (name == "entry" || name == "exit" || name == "callflow") {
+                continue;
+            }
+
+            std::cerr << "ERROR: Unrecognized annotation '" << name
+                      << "' for method: " << method->name() << ". An annotation should be one of: "
+                      << "entry, exit, callflow." << std::endl;
+            return UNKNOWN_ERROR;
+        }
+    }
+    return OK;
+}
+
 bool Interface::addAllReservedMethods() {
     // use a sorted map to insert them in serial ID order.
     std::map<int32_t, Method *> reservedMethodsById;
@@ -492,15 +616,14 @@
             || fillDebugMethod(method);
 
         if (!fillSuccess) {
-            LOG(ERROR) << "ERROR: hidl-gen does not recognize a reserved method "
-                       << method->name();
+            std::cerr << "ERROR: hidl-gen does not recognize a reserved method " << method->name()
+                      << std::endl;
             return false;
         }
         if (!reservedMethodsById.emplace(method->getSerialId(), method).second) {
-            LOG(ERROR) << "ERROR: hidl-gen uses duplicated serial id for "
-                       << method->name() << " and "
-                       << reservedMethodsById[method->getSerialId()]->name()
-                       << ", serialId = " << method->getSerialId();
+            std::cerr << "ERROR: hidl-gen uses duplicated serial id for " << method->name()
+                      << " and " << reservedMethodsById[method->getSerialId()]->name()
+                      << ", serialId = " << method->getSerialId() << std::endl;
             return false;
         }
     }
@@ -510,8 +633,14 @@
     return true;
 }
 
-const Interface *Interface::superType() const {
-    return mSuperType;
+const Interface* Interface::superType() const {
+    if (isIBase()) return nullptr;
+    if (!mSuperType->isInterface()) {
+        // This is actually an error
+        // that would be caught in validate
+        return nullptr;
+    }
+    return static_cast<const Interface*>(mSuperType.get());
 }
 
 std::vector<const Interface *> Interface::typeChain() const {
@@ -519,13 +648,13 @@
     const Interface *iface = this;
     while (iface != nullptr) {
         v.push_back(iface);
-        iface = iface->mSuperType;
+        iface = iface->superType();
     }
     return v;
 }
 
 std::vector<const Interface *> Interface::superTypeChain() const {
-    return superType()->typeChain(); // should work even if superType is nullptr
+    return isIBase() ? std::vector<const Interface*>() : superType()->typeChain();
 }
 
 bool Interface::isElidableType() const {
@@ -571,21 +700,18 @@
     return v;
 }
 
-Method *Interface::lookupMethod(std::string name) const {
-    for (const auto &tuple : allMethodsFromRoot()) {
-        Method *method = tuple.method();
-        if (method->name() == name) {
-            return method;
-        }
-    }
-
-    return nullptr;
+std::vector<InterfaceAndMethod> Interface::allSuperMethodsFromRoot() const {
+    return isIBase() ? std::vector<InterfaceAndMethod>() : superType()->allMethodsFromRoot();
 }
 
 std::string Interface::getBaseName() const {
     return fqName().getInterfaceBaseName();
 }
 
+std::string Interface::getAdapterName() const {
+    return fqName().getInterfaceAdapterName();
+}
+
 std::string Interface::getProxyName() const {
     return fqName().getInterfaceProxyName();
 }
@@ -658,8 +784,7 @@
         out << "{\n";
         out.indent();
 
-        const std::string binderName = "_hidl_" + name + "_binder";
-
+        const std::string binderName = "_hidl_binder";
         out << "::android::sp<::android::hardware::IBinder> "
             << binderName << ";\n";
 
@@ -720,29 +845,10 @@
     }
 }
 
-status_t Interface::emitGlobalTypeDeclarations(Formatter &out) const {
-    status_t status = Scope::emitGlobalTypeDeclarations(out);
-    if (status != OK) {
-        return status;
-    }
-    out << "std::string toString("
-        << getCppArgumentType()
-        << ");\n";
-    return OK;
-}
+void Interface::emitPackageTypeDeclarations(Formatter& out) const {
+    Scope::emitPackageTypeDeclarations(out);
 
-
-status_t Interface::emitTypeDefinitions(
-        Formatter &out, const std::string prefix) const {
-    std::string space = prefix.empty() ? "" : (prefix + "::");
-    status_t err = Scope::emitTypeDefinitions(out, space + localName());
-    if (err != OK) {
-        return err;
-    }
-
-    out << "std::string toString("
-        << getCppArgumentType()
-        << " o) ";
+    out << "static inline std::string toString(" << getCppArgumentType() << " o) ";
 
     out.block([&] {
         out << "std::string os = \"[class or subclass of \";\n"
@@ -751,8 +857,12 @@
             << "os += o->isRemote() ? \"@remote\" : \"@local\";\n"
             << "return os;\n";
     }).endl().endl();
+}
 
-    return OK;
+void Interface::emitTypeDefinitions(Formatter& out, const std::string& prefix) const {
+    std::string space = prefix.empty() ? "" : (prefix + "::");
+
+    Scope::emitTypeDefinitions(out, space + localName());
 }
 
 void Interface::emitJavaReaderWriter(
@@ -775,7 +885,7 @@
     }
 }
 
-status_t Interface::emitVtsAttributeDeclaration(Formatter &out) const {
+void Interface::emitVtsAttributeDeclaration(Formatter& out) const {
     for (const auto &type : getSubTypes()) {
         // Skip for TypeDef as it is just an alias of a defined type.
         if (type->isTypeDef()) {
@@ -783,17 +893,13 @@
         }
         out << "attribute: {\n";
         out.indent();
-        status_t status = type->emitVtsTypeDeclarations(out);
-        if (status != OK) {
-            return status;
-        }
+        type->emitVtsTypeDeclarations(out);
         out.unindent();
         out << "}\n\n";
     }
-    return OK;
 }
 
-status_t Interface::emitVtsMethodDeclaration(Formatter &out) const {
+void Interface::emitVtsMethodDeclaration(Formatter& out) const {
     for (const auto &method : methods()) {
         if (method->isHidlReserved()) {
             continue;
@@ -806,10 +912,7 @@
         for (const auto &result : method->results()) {
             out << "return_type_hidl: {\n";
             out.indent();
-            status_t status = result->type().emitVtsAttributeType(out);
-            if (status != OK) {
-                return status;
-            }
+            result->type().emitVtsAttributeType(out);
             out.unindent();
             out << "}\n";
         }
@@ -817,10 +920,7 @@
         for (const auto &arg : method->args()) {
             out << "arg: {\n";
             out.indent();
-            status_t status = arg->type().emitVtsAttributeType(out);
-            if (status != OK) {
-                return status;
-            }
+            arg->type().emitVtsAttributeType(out);
             out.unindent();
             out << "}\n";
         }
@@ -828,7 +928,7 @@
         for (const auto &annotation : method->annotations()) {
             out << "callflow: {\n";
             out.indent();
-            std::string name = annotation->name();
+            const std::string name = annotation->name();
             if (name == "entry") {
                 out << "entry: true\n";
             } else if (name == "exit") {
@@ -837,15 +937,12 @@
                 const AnnotationParam *param =
                         annotation->getParam("next");
                 if (param != nullptr) {
-                    for (auto value : *param->getValues()) {
+                    for (const auto& value : param->getValues()) {
                         out << "next: " << value << "\n";
                     }
                 }
             } else {
-                std::cerr << "Unrecognized annotation '"
-                          << name << "' for method: " << method->name()
-                          << ". A VTS annotation should be one of: "
-                          << "entry, exit, callflow. \n";
+                CHECK(false);
             }
             out.unindent();
             out << "}\n";
@@ -853,15 +950,13 @@
         out.unindent();
         out << "}\n\n";
     }
-    return OK;
 }
 
-status_t Interface::emitVtsAttributeType(Formatter &out) const {
+void Interface::emitVtsAttributeType(Formatter& out) const {
     out << "type: " << getVtsType() << "\n"
         << "predefined_type: \""
         << fullName()
         << "\"\n";
-    return OK;
 }
 
 bool Interface::hasOnewayMethods() const {
@@ -880,37 +975,21 @@
     return false;
 }
 
-bool Interface::isJavaCompatible() const {
-    if (mIsJavaCompatibleInProgress) {
-        // We're currently trying to determine if this Interface is
-        // java-compatible and something is referencing this interface through
-        // one of its methods. Assume we'll ultimately succeed, if we were wrong
-        // the original invocation of Interface::isJavaCompatible() will then
-        // return the correct "false" result.
-        return true;
-    }
-
-    if (mSuperType != nullptr && !mSuperType->isJavaCompatible()) {
-        mIsJavaCompatibleInProgress = false;
+bool Interface::deepIsJavaCompatible(std::unordered_set<const Type*>* visited) const {
+    if (superType() != nullptr && !superType()->isJavaCompatible(visited)) {
         return false;
     }
 
-    mIsJavaCompatibleInProgress = true;
-
-    if (!Scope::isJavaCompatible()) {
-        mIsJavaCompatibleInProgress = false;
-        return false;
-    }
-
-    for (const auto &method : methods()) {
-        if (!method->isJavaCompatible()) {
-            mIsJavaCompatibleInProgress = false;
+    for (const auto* method : methods()) {
+        if (!method->deepIsJavaCompatible(visited)) {
             return false;
         }
     }
 
-    mIsJavaCompatibleInProgress = false;
+    return Scope::isJavaCompatible(visited);
+}
 
+bool Interface::isNeverStrongReference() const {
     return true;
 }
 
diff --git a/Interface.h b/Interface.h
index b37dc60..0c94c0c 100644
--- a/Interface.h
+++ b/Interface.h
@@ -18,16 +18,28 @@
 
 #define INTERFACE_H_
 
-#include "Scope.h"
 #include <vector>
 
+#include <hidl-hash/Hash.h>
+
+#include "Reference.h"
+#include "Scope.h"
+
 namespace android {
 
 struct Method;
 struct InterfaceAndMethod;
 
 struct Interface : public Scope {
-    Interface(const char* localName, const Location& location, Scope* parent, Interface* super);
+    enum {
+        /////////////////// Flag(s) - DO NOT CHANGE
+        FLAG_ONEWAY = 0x00000001,
+    };
+
+    Interface(const char* localName, const FQName& fullName, const Location& location,
+              Scope* parent, const Reference<Type>& superType, const Hash* fileHash);
+
+    const Hash* getFileHash() const;
 
     bool addMethod(Method *method);
     bool addAllReservedMethods();
@@ -35,13 +47,11 @@
     bool isElidableType() const override;
     bool isInterface() const override;
     bool isBinder() const override;
-    bool isRootType() const { return mSuperType == nullptr; }
     bool isIBase() const { return fqName() == gIBaseFqName; }
     std::string typeName() const override;
 
-    const Interface *superType() const;
+    const Interface* superType() const;
 
-    Method *lookupMethod(std::string name) const;
     // Super type chain to root type.
     // First element is superType().
     std::vector<const Interface *> superTypeChain() const;
@@ -65,8 +75,12 @@
     // this->hidlReservedMethods()
     std::vector<InterfaceAndMethod> allMethodsFromRoot() const;
 
+    // allMethodsFromRoot for parent
+    std::vector<InterfaceAndMethod> allSuperMethodsFromRoot() const;
+
     // aliases for corresponding methods in this->fqName()
     std::string getBaseName() const;
+    std::string getAdapterName() const;
     std::string getProxyName() const;
     std::string getStubName() const;
     std::string getPassthroughName() const;
@@ -82,6 +96,16 @@
     std::string getJavaType(bool forInitializer) const override;
     std::string getVtsType() const override;
 
+    std::vector<const Reference<Type>*> getReferences() const override;
+    std::vector<const Reference<Type>*> getStrongReferences() const override;
+
+    std::vector<const ConstantExpression*> getConstantExpressions() const override;
+
+    status_t resolveInheritance() override;
+    status_t validate() const override;
+    status_t validateUniqueNames() const;
+    status_t validateAnnotations() const;
+
     void emitReaderWriter(
             Formatter &out,
             const std::string &name,
@@ -90,40 +114,49 @@
             bool isReader,
             ErrorMode mode) const override;
 
-    status_t emitGlobalTypeDeclarations(Formatter &out) const override;
-    status_t emitTypeDefinitions(
-            Formatter &out, const std::string prefix) const override;
+    void emitPackageTypeDeclarations(Formatter& out) const override;
+    void emitTypeDefinitions(Formatter& out, const std::string& prefix) const override;
 
+    void getAlignmentAndSize(size_t* align, size_t* size) const override;
     void emitJavaReaderWriter(
             Formatter &out,
             const std::string &parcelObj,
             const std::string &argName,
             bool isReader) const override;
 
-    status_t emitVtsAttributeType(Formatter &out) const override;
+    void emitVtsAttributeType(Formatter& out) const override;
 
-    status_t emitVtsAttributeDeclaration(Formatter &out) const;
-    status_t emitVtsMethodDeclaration(Formatter &out) const;
+    void emitVtsAttributeDeclaration(Formatter& out) const;
+    void emitVtsMethodDeclaration(Formatter& out) const;
 
     bool hasOnewayMethods() const;
 
-    bool isJavaCompatible() const override;
+    bool deepIsJavaCompatible(std::unordered_set<const Type*>* visited) const override;
 
-private:
-    Interface *mSuperType;
-    std::vector<Method *> mUserMethods;
-    std::vector<Method *> mReservedMethods;
-    mutable bool mIsJavaCompatibleInProgress;
-    bool fillPingMethod(Method *method) const;
-    bool fillDescriptorChainMethod(Method *method) const;
-    bool fillGetDescriptorMethod(Method *method) const;
-    bool fillHashChainMethod(Method *method) const;
-    bool fillSyspropsChangedMethod(Method *method) const;
-    bool fillLinkToDeathMethod(Method *method) const;
-    bool fillUnlinkToDeathMethod(Method *method) const;
-    bool fillSetHALInstrumentationMethod(Method *method) const;
-    bool fillGetDebugInfoMethod(Method *method) const;
-    bool fillDebugMethod(Method *method) const;
+    bool isNeverStrongReference() const override;
+
+   private:
+    Reference<Type> mSuperType;
+
+    std::vector<Method*> mUserMethods;
+    std::vector<Method*> mReservedMethods;
+
+    const Hash* mFileHash;
+
+    bool fillPingMethod(Method* method) const;
+    bool fillDescriptorChainMethod(Method* method) const;
+    bool fillGetDescriptorMethod(Method* method) const;
+    bool fillHashChainMethod(Method* method) const;
+    bool fillSyspropsChangedMethod(Method* method) const;
+    bool fillLinkToDeathMethod(Method* method) const;
+    bool fillUnlinkToDeathMethod(Method* method) const;
+    bool fillSetHALInstrumentationMethod(Method* method) const;
+    bool fillGetDebugInfoMethod(Method* method) const;
+    bool fillDebugMethod(Method* method) const;
+
+    void emitDigestChain(
+        Formatter& out, const std::string& prefix, const std::vector<const Interface*>& chain,
+        std::function<std::string(std::unique_ptr<ConstantExpression>)> byteToString) const;
 
     DISALLOW_COPY_AND_ASSIGN(Interface);
 };
@@ -135,7 +168,8 @@
           mMethod(method) {}
     Method *method() const { return mMethod; }
     const Interface *interface() const { return mInterface; }
-private:
+
+   private:
     // do not own these objects.
     const Interface *mInterface;
     Method *mMethod;
diff --git a/Location.cpp b/Location.cpp
new file mode 100644
index 0000000..2d834fb
--- /dev/null
+++ b/Location.cpp
@@ -0,0 +1,113 @@
+/*
+ * Copyright (C) 2017 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 "Location.h"
+
+#include <android-base/logging.h>
+
+namespace android {
+
+Position::Position(std::string filename, size_t line, size_t column)
+    : mFilename(filename), mLine(line), mColumn(column) {}
+
+const std::string& Position::filename() const {
+    return mFilename;
+}
+
+size_t Position::line() const {
+    return mLine;
+}
+
+size_t Position::column() const {
+    return mColumn;
+}
+
+bool Position::inSameFile(const Position& lhs, const Position& rhs) {
+    return lhs.mFilename == rhs.mFilename;
+}
+
+bool Position::operator<(const Position& pos) const {
+    CHECK(inSameFile(*this, pos)) << "Cannot compare positions in different files";
+    if (mLine == pos.mLine) {
+        return mColumn < pos.mColumn;
+    }
+    return mLine < pos.mLine;
+}
+
+std::ostream& operator<<(std::ostream& ostr, const Position& pos) {
+    if (!pos.filename().empty()) {
+        ostr << pos.filename() << ":";
+    }
+    return ostr << pos.line() << "." << pos.column();
+}
+
+////////////////////////////////////////
+
+Location::Location(const Position& begin, const Position& end)
+    : mIsValid(true), mBegin(begin), mEnd(end) {}
+
+void Location::setLocation(const Position& begin, const Position& end) {
+    mIsValid = true;
+    mBegin = begin;
+    mEnd = end;
+}
+
+bool Location::isValid() const {
+    return mIsValid;
+}
+
+const Position& Location::begin() const {
+    return mBegin;
+}
+
+const Position& Location::end() const {
+    return mEnd;
+}
+
+Location Location::startOf(const std::string& path) {
+    return Location(Position(path, 1, 1), Position(path, 1, 1));
+}
+
+bool Location::inSameFile(const Location& lhs, const Location& rhs) {
+    return Position::inSameFile(lhs.mBegin, rhs.mBegin);
+}
+
+bool Location::intersect(const Location& lhs, const Location& rhs) {
+    if (!inSameFile(lhs, rhs)) return false;
+    return !(lhs.mEnd < rhs.mBegin || rhs.mEnd < lhs.mBegin);
+}
+
+bool Location::operator<(const Location& loc) const {
+    CHECK(inSameFile(*this, loc)) << "Cannot compare locations in different files";
+    CHECK(!intersect(*this, loc));
+    return mEnd < loc.mBegin;
+}
+
+std::ostream& operator<<(std::ostream& ostr, const Location& loc) {
+    Position last = Position(loc.end().filename(), loc.end().line(),
+                             std::max<size_t>(1u, loc.end().column() - 1));
+    ostr << loc.begin();
+    if (loc.begin().filename() != last.filename()) {
+        ostr << "-" << last;
+    } else if (loc.begin().line() != last.line()) {
+        ostr << "-" << last.line() << "." << last.column();
+    } else if (loc.begin().column() != last.column()) {
+        ostr << "-" << last.column();
+    }
+    return ostr;
+}
+
+}  // namespace android
diff --git a/Location.h b/Location.h
index 84dfc0e..2e99ab8 100644
--- a/Location.h
+++ b/Location.h
@@ -17,68 +17,67 @@
 #ifndef LOCATION_H_
 #define LOCATION_H_
 
-#include <iostream>
 #include <stdint.h>
+#include <ostream>
 #include <string>
 
 // Mimics for yy::location and yy::position
 namespace android {
 
 struct Position {
-    Position(std::string f, size_t l, size_t c)
-            : mFilename(f), mLine(l), mColumn(c) {}
-    inline const std::string &filename() const { return mFilename; }
-    inline size_t line() const { return mLine; }
-    inline size_t column() const { return mColumn; }
+    Position() = default;
+    Position(std::string filename, size_t line, size_t column);
 
-private:
+    const std::string& filename() const;
+
+    size_t line() const;
+    size_t column() const;
+
+    static bool inSameFile(const Position& lhs, const Position& rhs);
+
+    // Precondition: inSameFile()
+    bool operator<(const Position& pos) const;
+
+   private:
     // File name to which this position refers.
-    const std::string mFilename;
+    std::string mFilename;
     // Current line number.
-    const size_t mLine;
+    size_t mLine;
     // Current column number.
-    const size_t mColumn;
+    size_t mColumn;
 };
 
-inline std::ostream& operator<< (std::ostream& ostr, const Position& pos) {
-    if (!pos.filename().empty()) {
-        ostr << pos.filename() << ":";
-    }
-    return ostr << pos.line() << "." << pos.column();
-}
+std::ostream& operator<<(std::ostream& ostr, const Position& pos);
 
 struct Location {
-    Location (Position begin, Position end)
-            : mBegin(begin), mEnd(end) {}
-    inline const Position &begin() const { return mBegin; }
-    inline const Position &end() const { return mEnd; }
+    Location() = default;
+    Location(const Position& begin, const Position& end);
 
-    inline static Location startOf(const std::string &path) {
-        return Location(Position(path, 1, 1), Position(path, 1, 1));
-    }
+    void setLocation(const Position& begin, const Position& end);
 
-private:
+    bool isValid() const;
+    const Position& begin() const;
+    const Position& end() const;
+
+    static Location startOf(const std::string& path);
+
+    static bool inSameFile(const Location& lhs, const Location& rhs);
+    static bool intersect(const Location& lhs, const Location& rhs);
+
+    // Precondition: inSameFile() && !intersect()
+    bool operator<(const Location& loc) const;
+
+   private:
+    bool mIsValid = false;
+
     // Beginning of the located region.
-    const Position mBegin;
+    Position mBegin;
     // End of the located region.
-    const Position mEnd;
+    Position mEnd;
 };
 
-inline std::ostream& operator<< (std::ostream& ostr, const Location& loc) {
-    Position last = Position(loc.end().filename(),
-            loc.end().line(),
-            std::max<size_t>(1u, loc.end().column() - 1));
-    ostr << loc.begin();
-    if (loc.begin().filename() != last.filename()) {
-        ostr << "-" << last;
-    } else if (loc.begin().line() != last.line()) {
-        ostr << "-" << last.line()  << "." << last.column();
-    } else if (loc.begin().column() != last.column()) {
-        ostr << "-" << last.column();
-    }
-    return ostr;
-}
+std::ostream& operator<<(std::ostream& ostr, const Location& loc);
 
 } // namespace android
 
-#endif
+#endif  // LOCATION_H_
diff --git a/MemoryType.cpp b/MemoryType.cpp
index 251691e..444ba92 100644
--- a/MemoryType.cpp
+++ b/MemoryType.cpp
@@ -23,7 +23,7 @@
 
 namespace android {
 
-MemoryType::MemoryType() {}
+MemoryType::MemoryType(Scope* parent) : Type(parent) {}
 
 std::string MemoryType::getCppType(StorageMode mode,
                                    bool specifyNamespaces) const {
@@ -145,7 +145,7 @@
     return true;
 }
 
-bool MemoryType::isJavaCompatible() const {
+bool MemoryType::deepIsJavaCompatible(std::unordered_set<const Type*>* /* visited */) const {
     return false;
 }
 
@@ -155,9 +155,8 @@
     *size = assertion.size();
 }
 
-status_t MemoryType::emitVtsTypeDeclarations(Formatter &out) const {
+void MemoryType::emitVtsTypeDeclarations(Formatter& out) const {
     out << "type: " << getVtsType() << "\n";
-    return OK;
 }
 
 }  // namespace android
diff --git a/MemoryType.h b/MemoryType.h
index cd7329a..7bce55f 100644
--- a/MemoryType.h
+++ b/MemoryType.h
@@ -23,7 +23,7 @@
 namespace android {
 
 struct MemoryType : public Type {
-    MemoryType();
+    MemoryType(Scope* parent);
 
     std::string typeName() const override;
 
@@ -58,11 +58,12 @@
     bool resultNeedsDeref() const override;
 
     bool isMemory() const override;
-    bool isJavaCompatible() const override;
+
+    bool deepIsJavaCompatible(std::unordered_set<const Type*>* visited) const override;
 
     void getAlignmentAndSize(size_t *align, size_t *size) const override;
 
-    status_t emitVtsTypeDeclarations(Formatter &out) const override;
+    void emitVtsTypeDeclarations(Formatter& out) const override;
 };
 
 }  // namespace android
diff --git a/Method.cpp b/Method.cpp
index 6c0ebf5..64a9a65 100644
--- a/Method.cpp
+++ b/Method.cpp
@@ -17,25 +17,25 @@
 #include "Method.h"
 
 #include "Annotation.h"
+#include "ConstantExpression.h"
 #include "ScalarType.h"
 #include "Type.h"
 
 #include <android-base/logging.h>
 #include <hidl-util/Formatter.h>
+#include <algorithm>
 
 namespace android {
 
-Method::Method(const char *name,
-       std::vector<TypedVar *> *args,
-       std::vector<TypedVar *> *results,
-       bool oneway,
-       std::vector<Annotation *> *annotations)
+Method::Method(const char* name, std::vector<NamedReference<Type>*>* args,
+               std::vector<NamedReference<Type>*>* results, bool oneway,
+               std::vector<Annotation*>* annotations, const Location& location)
     : mName(name),
       mArgs(args),
       mResults(results),
       mOneway(oneway),
-      mAnnotations(annotations) {
-}
+      mAnnotations(annotations),
+      mLocation(location) {}
 
 void Method::fillImplementation(
         size_t serial,
@@ -57,11 +57,11 @@
     return mName;
 }
 
-const std::vector<TypedVar *> &Method::args() const {
+const std::vector<NamedReference<Type>*>& Method::args() const {
     return *mArgs;
 }
 
-const std::vector<TypedVar *> &Method::results() const {
+const std::vector<NamedReference<Type>*>& Method::results() const {
     return *mResults;
 }
 
@@ -69,6 +69,56 @@
     return *mAnnotations;
 }
 
+std::vector<Reference<Type>*> Method::getReferences() {
+    const auto& constRet = static_cast<const Method*>(this)->getReferences();
+    std::vector<Reference<Type>*> ret(constRet.size());
+    std::transform(constRet.begin(), constRet.end(), ret.begin(),
+                   [](const auto* ref) { return const_cast<Reference<Type>*>(ref); });
+    return ret;
+}
+
+std::vector<const Reference<Type>*> Method::getReferences() const {
+    std::vector<const Reference<Type>*> ret;
+    ret.insert(ret.end(), mArgs->begin(), mArgs->end());
+    ret.insert(ret.end(), mResults->begin(), mResults->end());
+    return ret;
+}
+
+std::vector<Reference<Type>*> Method::getStrongReferences() {
+    const auto& constRet = static_cast<const Method*>(this)->getStrongReferences();
+    std::vector<Reference<Type>*> ret(constRet.size());
+    std::transform(constRet.begin(), constRet.end(), ret.begin(),
+                   [](const auto* ref) { return const_cast<Reference<Type>*>(ref); });
+    return ret;
+}
+
+std::vector<const Reference<Type>*> Method::getStrongReferences() const {
+    std::vector<const Reference<Type>*> ret;
+    for (const auto* ref : getReferences()) {
+        if (!ref->shallowGet()->isNeverStrongReference()) {
+            ret.push_back(ref);
+        }
+    }
+    return ret;
+}
+
+std::vector<ConstantExpression*> Method::getConstantExpressions() {
+    const auto& constRet = static_cast<const Method*>(this)->getConstantExpressions();
+    std::vector<ConstantExpression*> ret(constRet.size());
+    std::transform(constRet.begin(), constRet.end(), ret.begin(),
+                   [](const auto* ce) { return const_cast<ConstantExpression*>(ce); });
+    return ret;
+}
+
+std::vector<const ConstantExpression*> Method::getConstantExpressions() const {
+    std::vector<const ConstantExpression*> ret;
+    for (const auto* annotation : *mAnnotations) {
+        const auto& retAnnotation = annotation->getConstantExpressions();
+        ret.insert(ret.end(), retAnnotation.begin(), retAnnotation.end());
+    }
+    return ret;
+}
+
 void Method::cppImpl(MethodImplType type, Formatter &out) const {
     CHECK(mIsHidlReserved);
     auto it = mCppImpl.find(type);
@@ -104,7 +154,7 @@
 }
 
 Method *Method::copySignature() const {
-    return new Method(mName.c_str(), mArgs, mResults, mOneway, mAnnotations);
+    return new Method(mName.c_str(), mArgs, mResults, mOneway, mAnnotations, Location());
 }
 
 void Method::setSerialId(size_t serial) {
@@ -121,7 +171,7 @@
 }
 
 void Method::generateCppReturnType(Formatter &out, bool specifyNamespaces) const {
-    const TypedVar *elidedReturn = canElideCallback();
+    const NamedReference<Type>* elidedReturn = canElideCallback();
     const std::string space = (specifyNamespaces ? "::android::hardware::" : "");
 
     if (elidedReturn == nullptr) {
@@ -149,9 +199,9 @@
     out << ")";
 }
 
-static void emitCppArgResultSignature(Formatter &out,
-                         const std::vector<TypedVar *> &args,
-                         bool specifyNamespaces) {
+static void emitCppArgResultSignature(Formatter& out,
+                                      const std::vector<NamedReference<Type>*>& args,
+                                      bool specifyNamespaces) {
     out.join(args.begin(), args.end(), ", ", [&](auto arg) {
         out << arg->type().getCppArgumentType(specifyNamespaces);
         out << " ";
@@ -159,7 +209,8 @@
     });
 }
 
-static void emitJavaArgResultSignature(Formatter &out, const std::vector<TypedVar *> &args) {
+static void emitJavaArgResultSignature(Formatter& out,
+                                       const std::vector<NamedReference<Type>*>& args) {
     out.join(args.begin(), args.end(), ", ", [&](auto arg) {
         out << arg->type().getJavaType();
         out << " ";
@@ -171,7 +222,7 @@
     emitCppArgResultSignature(out, args(), specifyNamespaces);
 
     const bool returnsValue = !results().empty();
-    const TypedVar *elidedReturn = canElideCallback();
+    const NamedReference<Type>* elidedReturn = canElideCallback();
     if (returnsValue && elidedReturn == nullptr) {
         if (!args().empty()) {
             out << ", ";
@@ -205,33 +256,31 @@
     out << "\n";
 }
 
-bool Method::isJavaCompatible() const {
+bool Method::deepIsJavaCompatible(std::unordered_set<const Type*>* visited) const {
     if (isHiddenFromJava()) {
         return true;
     }
 
-    for (const auto &arg : *mArgs) {
-        if (!arg->isJavaCompatible()) {
-            return false;
-        }
+    if (!std::all_of(mArgs->begin(), mArgs->end(),
+                     [&](const auto* arg) { return (*arg)->isJavaCompatible(visited); })) {
+        return false;
     }
 
-    for (const auto &result : *mResults) {
-        if (!result->isJavaCompatible()) {
-            return false;
-        }
+    if (!std::all_of(mResults->begin(), mResults->end(),
+                     [&](const auto* arg) { return (*arg)->isJavaCompatible(visited); })) {
+        return false;
     }
 
     return true;
 }
 
-const TypedVar* Method::canElideCallback() const {
+const NamedReference<Type>* Method::canElideCallback() const {
     // Can't elide callback for void or tuple-returning methods
     if (mResults->size() != 1) {
         return nullptr;
     }
 
-    const TypedVar *typedVar = mResults->at(0);
+    const NamedReference<Type>* typedVar = mResults->at(0);
 
     if (typedVar->type().isElidableType()) {
         return typedVar;
@@ -240,27 +289,13 @@
     return nullptr;
 }
 
-////////////////////////////////////////////////////////////////////////////////
-
-TypedVar::TypedVar(const char *name, Type *type)
-    : mName(name),
-      mType(type) {
-}
-
-std::string TypedVar::name() const {
-    return mName;
-}
-
-const Type &TypedVar::type() const {
-    return *mType;
-}
-
-bool TypedVar::isJavaCompatible() const {
-    return mType->isJavaCompatible();
+const Location& Method::location() const {
+    return mLocation;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
-bool TypedVarVector::add(TypedVar *v) {
+
+bool TypedVarVector::add(NamedReference<Type>* v) {
     if (mNames.emplace(v->name()).second) {
         push_back(v);
         return true;
diff --git a/Method.h b/Method.h
index 6d7664b..711f087 100644
--- a/Method.h
+++ b/Method.h
@@ -19,20 +19,26 @@
 #define METHOD_H_
 
 #include <android-base/macros.h>
-#include <functional>
 #include <hidl-util/Formatter.h>
+#include <utils/Errors.h>
+#include <functional>
 #include <map>
 #include <set>
 #include <string>
+#include <unordered_set>
 #include <vector>
 
+#include "DocComment.h"
+#include "Location.h"
+#include "Reference.h"
+
 namespace android {
 
 struct Annotation;
+struct ConstantExpression;
 struct Formatter;
 struct ScalarType;
 struct Type;
-struct TypedVar;
 struct TypedVarVector;
 
 enum MethodImplType {
@@ -45,16 +51,14 @@
 
 using MethodImpl = std::map<MethodImplType, std::function<void(Formatter &)>>;
 
-struct Method {
-    Method(const char *name,
-           std::vector<TypedVar *> *args,
-           std::vector<TypedVar *> *results,
-           bool oneway,
-           std::vector<Annotation *> *annotations);
+struct Method : DocCommentable {
+    Method(const char* name, std::vector<NamedReference<Type>*>* args,
+           std::vector<NamedReference<Type>*>* results, bool oneway,
+           std::vector<Annotation*>* annotations, const Location& location);
 
     std::string name() const;
-    const std::vector<TypedVar *> &args() const;
-    const std::vector<TypedVar *> &results() const;
+    const std::vector<NamedReference<Type>*>& args() const;
+    const std::vector<NamedReference<Type>*>& results() const;
     bool isOneway() const { return mOneway; }
     bool overridesCppImpl(MethodImplType type) const;
     bool overridesJavaImpl(MethodImplType type) const;
@@ -64,6 +68,15 @@
     bool isHiddenFromJava() const;
     const std::vector<Annotation *> &annotations() const;
 
+    std::vector<Reference<Type>*> getReferences();
+    std::vector<const Reference<Type>*> getReferences() const;
+
+    std::vector<Reference<Type>*> getStrongReferences();
+    std::vector<const Reference<Type>*> getStrongReferences() const;
+
+    std::vector<ConstantExpression*> getConstantExpressions();
+    std::vector<const ConstantExpression*> getConstantExpressions() const;
+
     // Make a copy with the same name, args, results, oneway, annotations.
     // Implementations, serial are not copied.
     Method *copySignature() const;
@@ -90,17 +103,19 @@
     void emitJavaArgSignature(Formatter &out) const;
     void emitJavaResultSignature(Formatter &out) const;
 
-    const TypedVar* canElideCallback() const;
+    const NamedReference<Type>* canElideCallback() const;
 
     void dumpAnnotations(Formatter &out) const;
 
-    bool isJavaCompatible() const;
+    bool deepIsJavaCompatible(std::unordered_set<const Type*>* visited) const;
 
-private:
+    const Location& location() const;
+
+   private:
     std::string mName;
     size_t mSerial = 0;
-    std::vector<TypedVar *> *mArgs;
-    std::vector<TypedVar *> *mResults;
+    std::vector<NamedReference<Type>*>* mArgs;
+    std::vector<NamedReference<Type>*>* mResults;
     bool mOneway;
     std::vector<Annotation *> *mAnnotations;
 
@@ -110,29 +125,17 @@
     MethodImpl mCppImpl;
     MethodImpl mJavaImpl;
 
+    const Location mLocation;
+
     DISALLOW_COPY_AND_ASSIGN(Method);
 };
 
-struct TypedVar {
-    TypedVar(const char *name, Type *type);
-
-    std::string name() const;
-    const Type &type() const;
-
-    bool isJavaCompatible() const;
-
-private:
-    std::string mName;
-    Type *mType;
-
-    DISALLOW_COPY_AND_ASSIGN(TypedVar);
-};
-
-struct TypedVarVector : public std::vector<TypedVar *> {
+struct TypedVarVector : public std::vector<NamedReference<Type>*> {
     TypedVarVector() = default;
 
-    bool add(TypedVar *v);
-private:
+    bool add(NamedReference<Type>* v);
+
+   private:
     std::set<std::string> mNames;
 };
 
diff --git a/NamedType.cpp b/NamedType.cpp
index f6d876f..645c63d 100644
--- a/NamedType.cpp
+++ b/NamedType.cpp
@@ -18,17 +18,14 @@
 
 namespace android {
 
-NamedType::NamedType(const char* localName, const Location& loc, Scope* parent)
-    : mLocalName(localName), mLocation(loc), mParent(parent) {}
+NamedType::NamedType(const char* localName, const FQName& fullName, const Location& loc,
+                     Scope* parent)
+    : Type(parent), mLocalName(localName), mFullName(fullName), mLocation(loc) {}
 
 bool NamedType::isNamedType() const {
     return true;
 }
 
-void NamedType::setFullName(const FQName &fullName) {
-    mFullName = fullName;
-}
-
 const FQName &NamedType::fqName() const {
     return mFullName;
 }
@@ -41,10 +38,6 @@
     return mFullName.cppName();
 }
 
-std::string NamedType::partialCppName() const {
-    return mFullName.cppLocalName();
-}
-
 std::string NamedType::fullJavaName() const {
     return mFullName.javaName();
 }
@@ -53,10 +46,6 @@
     return mLocation;
 }
 
-Scope* NamedType::parent() const {
-    return mParent;
-}
-
 void NamedType::emitDump(
         Formatter &out,
         const std::string &streamName,
diff --git a/NamedType.h b/NamedType.h
index cfc3df8..857f3a3 100644
--- a/NamedType.h
+++ b/NamedType.h
@@ -27,41 +27,31 @@
 
 namespace android {
 
-struct Scope;
-
 struct NamedType : public Type {
-    NamedType(const char* localName, const Location& loc, Scope* parent);
+    NamedType(const char* localName, const FQName& fullName, const Location& loc, Scope* parent);
 
     bool isNamedType() const override;
 
-    void setFullName(const FQName &fullName);
-
     const FQName &fqName() const;
 
     std::string localName() const;
 
     /* short for fqName().cppName() */
     std::string fullName() const;
-    /* short for fqName().cppLocalName() */
-    std::string partialCppName() const;
     /* short for fqName().fullJavaName() */
     std::string fullJavaName() const;
 
-    // returns null if no location is set for this type.
-    const Location &location() const;
+    const Location& location() const;
 
     void emitDump(
             Formatter &out,
             const std::string &streamName,
             const std::string &name) const override;
 
-    Scope* parent() const;
-
    private:
-    std::string mLocalName;
-    FQName mFullName;
-    Location mLocation;
-    Scope* const mParent;
+    const std::string mLocalName;
+    const FQName mFullName;
+    const Location mLocation;
 
     DISALLOW_COPY_AND_ASSIGN(NamedType);
 };
diff --git a/PointerType.cpp b/PointerType.cpp
index 8684e4e..cdf4a99 100644
--- a/PointerType.cpp
+++ b/PointerType.cpp
@@ -21,7 +21,7 @@
 
 namespace android {
 
-PointerType::PointerType() {}
+PointerType::PointerType(Scope* parent) : Type(parent) {}
 
 bool PointerType::isPointer() const {
     return true;
@@ -63,17 +63,16 @@
     return false;
 }
 
-bool PointerType::isJavaCompatible() const {
+bool PointerType::deepIsJavaCompatible(std::unordered_set<const Type*>* /* visited */) const {
     return false;
 }
 
-bool PointerType::containsPointer() const {
+bool PointerType::deepContainsPointer(std::unordered_set<const Type*>* /* visited */) const {
     return true;
 }
 
-status_t PointerType::emitVtsTypeDeclarations(Formatter &out) const {
+void PointerType::emitVtsTypeDeclarations(Formatter& out) const {
     out << "type: " << getVtsType() << "\n";
-    return OK;
 }
 
 }  // namespace android
diff --git a/PointerType.h b/PointerType.h
index 4fb6a2f..30c4a32 100644
--- a/PointerType.h
+++ b/PointerType.h
@@ -23,7 +23,7 @@
 namespace android {
 
 struct PointerType : public Type {
-    PointerType();
+    PointerType(Scope* parent);
 
     bool isPointer() const override;
 
@@ -48,10 +48,10 @@
     bool needsEmbeddedReadWrite() const override;
     bool resultNeedsDeref() const override;
 
-    bool isJavaCompatible() const override;
-    bool containsPointer() const override;
+    bool deepIsJavaCompatible(std::unordered_set<const Type*>* visited) const override;
+    bool deepContainsPointer(std::unordered_set<const Type*>* visited) const override;
 
-    status_t emitVtsTypeDeclarations(Formatter &out) const override;
+    void emitVtsTypeDeclarations(Formatter& out) const override;
 };
 
 }  // namespace android
diff --git a/RefType.cpp b/RefType.cpp
index b43c832..9947399 100644
--- a/RefType.cpp
+++ b/RefType.cpp
@@ -24,11 +24,14 @@
 
 namespace android {
 
-RefType::RefType() {
+RefType::RefType(Scope* parent) : TemplatedType(parent) {}
+
+std::string RefType::templatedTypeName() const {
+    return "ref";
 }
 
-std::string RefType::typeName() const {
-    return "ref" + (mElementType == nullptr ? "" : (" of " + mElementType->typeName()));
+std::vector<const Reference<Type>*> RefType::getStrongReferences() const {
+    return {};
 }
 
 std::string RefType::getVtsType() const {
@@ -39,7 +42,7 @@
     return "ref_value";
 }
 
-bool RefType::isCompatibleElementType(Type *elementType) const {
+bool RefType::isCompatibleElementType(const Type* elementType) const {
     if (elementType->isScalar()) {
         return true;
     }
@@ -52,15 +55,17 @@
     if (elementType->isBitField()) {
         return true;
     }
-    if (elementType->isCompoundType()
-            && static_cast<CompoundType *>(elementType)->style() == CompoundType::STYLE_STRUCT) {
+    if (elementType->isCompoundType() &&
+        static_cast<const CompoundType*>(elementType)->style() == CompoundType::STYLE_STRUCT) {
         return true;
     }
     if (elementType->isTemplatedType()) {
-        return this->isCompatibleElementType(static_cast<TemplatedType *>(elementType)->getElementType());
+        return this->isCompatibleElementType(
+            static_cast<const TemplatedType*>(elementType)->getElementType());
     }
     if (elementType->isArray()) {
-        return this->isCompatibleElementType(static_cast<ArrayType *>(elementType)->getElementType());
+        return this->isCompatibleElementType(
+            static_cast<const ArrayType*>(elementType)->getElementType());
     }
     return false;
 }
@@ -225,7 +230,7 @@
     out << "}\n\n";
 }
 
-bool RefType::needsResolveReferences() const {
+bool RefType::deepNeedsResolveReferences(std::unordered_set<const Type*>* /* visited */) const {
     return true;
 }
 
@@ -237,11 +242,11 @@
     return false;
 }
 
-bool RefType::isJavaCompatible() const {
+bool RefType::deepIsJavaCompatible(std::unordered_set<const Type*>* /* visited */) const {
     return false;
 }
 
-bool RefType::containsPointer() const {
+bool RefType::deepContainsPointer(std::unordered_set<const Type*>* /* visited */) const {
     return true;
 }
 
diff --git a/RefType.h b/RefType.h
index c44b8ad..d7b428c 100644
--- a/RefType.h
+++ b/RefType.h
@@ -18,15 +18,21 @@
 
 #define REF_TYPE_H_
 
+#include <vector>
+
+#include "Reference.h"
 #include "Type.h"
 
 namespace android {
 
 struct RefType : public TemplatedType {
-    RefType();
+    RefType(Scope* parent);
 
-    std::string typeName() const override;
-    bool isCompatibleElementType(Type *elementType) const override;
+    std::string templatedTypeName() const override;
+
+    bool isCompatibleElementType(const Type* elementType) const override;
+
+    std::vector<const Reference<Type>*> getStrongReferences() const override;
 
     std::string getCppType(StorageMode mode,
                            bool specifyNamespaces) const override;
@@ -65,13 +71,13 @@
             const std::string &offsetText) const override;
 
     bool needsEmbeddedReadWrite() const override;
-    bool needsResolveReferences() const override;
+    bool deepNeedsResolveReferences(std::unordered_set<const Type*>* visited) const override;
     bool resultNeedsDeref() const override;
 
-    bool isJavaCompatible() const override;
-    bool containsPointer() const override;
+    bool deepIsJavaCompatible(std::unordered_set<const Type*>* visited) const override;
+    bool deepContainsPointer(std::unordered_set<const Type*>* visited) const override;
 
- private:
+   private:
     DISALLOW_COPY_AND_ASSIGN(RefType);
 };
 
diff --git a/Reference.h b/Reference.h
new file mode 100644
index 0000000..7ddc889
--- /dev/null
+++ b/Reference.h
@@ -0,0 +1,139 @@
+/*
+ * Copyright (C) 2017 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.
+ */
+
+#ifndef REFERENCE_H_
+
+#define REFERENCE_H_
+
+#include <android-base/logging.h>
+#include <hidl-util/FQName.h>
+
+#include "DocComment.h"
+#include "Location.h"
+
+namespace android {
+
+/**
+ * Reference placeholder
+ */
+template <class T>
+struct Reference {
+    Reference() = default;
+    virtual ~Reference() {}
+
+    Reference(const FQName& fqName, const Location& location)
+        : mResolved(nullptr), mFqName(fqName), mLocation(location) {}
+
+    Reference(T* type, const Location& location) : mResolved(type), mLocation(location) {
+        CHECK(type != nullptr);
+    }
+
+    template <class OtherT>
+    Reference(const Reference<OtherT>& ref)
+        : mResolved(ref.mResolved), mFqName(ref.mFqName), mLocation(ref.mLocation) {}
+
+    template <class OtherT>
+    Reference(const Reference<OtherT>& ref, const Location& location)
+        : mResolved(ref.mResolved), mFqName(ref.mFqName), mLocation(location) {}
+
+    /* Returns true iff referred type is resolved
+       Referred type's field might be not resolved */
+    bool isResolved() const { return mResolved != nullptr; }
+
+    T* operator->() { return get(); }
+    const T* operator->() const { return get(); }
+
+    /* Returns referenced object.
+       If a type is referenced, all typedefs are unwrapped. */
+    T* get() {
+        CHECK(mResolved != nullptr);
+        return mResolved->resolve();
+    }
+    const T* get() const {
+        CHECK(mResolved != nullptr);
+        return mResolved->resolve();
+    }
+
+    /* Returns exact referenced object.
+       If a type is referenced, typedefs are not unwraped. */
+    T* shallowGet() {
+        CHECK(mResolved != nullptr);
+        return mResolved;
+    }
+    const T* shallowGet() const {
+        CHECK(mResolved != nullptr);
+        return mResolved;
+    }
+
+    void set(T* resolved) {
+        CHECK(!isResolved());
+        CHECK(resolved != nullptr);
+        mResolved = resolved;
+    }
+
+    /* Returns true iff this is reference to null:
+       not resolved and has not name for lookup */
+    bool isEmptyReference() const { return !isResolved() && !hasLookupFqName(); }
+
+    const FQName& getLookupFqName() const {
+        CHECK(hasLookupFqName());
+        return mFqName;
+    }
+
+    bool hasLocation() const { return mLocation.isValid(); }
+
+    const Location& location() const {
+        CHECK(hasLocation());
+        return mLocation;
+    }
+
+   private:
+    /* Referred type */
+    T* mResolved = nullptr;
+    /* Reference name for lookup */
+    FQName mFqName;
+    /* Reference location is mainly used for printing errors
+       and handling forward reference restrictions */
+    Location mLocation;
+
+    bool hasLookupFqName() const {
+        // Valid only while not resolved to prevent confusion when
+        // ref.hasLookupFqName() is false while ref,get()->fqName is valid.
+        CHECK(!isResolved());
+        return mFqName.isValid();
+    }
+
+    template <class OtherT>
+    friend struct Reference;
+};
+
+template <class T>
+struct NamedReference : public Reference<T>, DocCommentable {
+    NamedReference(const std::string& name, const Reference<T>& reference, const Location& location)
+        : Reference<T>(reference, location), mName(name) {}
+
+    const std::string& name() const { return mName; }
+
+    // TODO(b/64715470) Legacy
+    const T& type() const { return *Reference<T>::get(); }
+
+   private:
+    const std::string mName;
+};
+
+}  // namespace android
+
+#endif  // REFERENCE_H_
diff --git a/ScalarType.cpp b/ScalarType.cpp
index fefd418..2e2e7b2 100644
--- a/ScalarType.cpp
+++ b/ScalarType.cpp
@@ -20,9 +20,7 @@
 
 namespace android {
 
-ScalarType::ScalarType(Kind kind)
-    : mKind(kind) {
-}
+ScalarType::ScalarType(Kind kind, Scope* parent) : Type(parent), mKind(kind) {}
 
 const ScalarType *ScalarType::resolveToScalarType() const {
     return this;
@@ -41,7 +39,7 @@
     return true;
 }
 
-bool ScalarType::canCheckEquality() const {
+bool ScalarType::deepCanCheckEquality(std::unordered_set<const Type*>* /* visited */) const {
     return true;
 }
 
@@ -279,10 +277,9 @@
         << ");\n";
 }
 
-status_t ScalarType::emitVtsTypeDeclarations(Formatter &out) const {
+void ScalarType::emitVtsTypeDeclarations(Formatter& out) const {
     out << "type: " << getVtsType() << "\n";
     out << "scalar_type: \"" << getVtsScalarType() << "\"\n";
-    return OK;
 }
 
 void ScalarType::getAlignmentAndSize(size_t *align, size_t *size) const {
diff --git a/ScalarType.h b/ScalarType.h
index 737da9a..86305b8 100644
--- a/ScalarType.h
+++ b/ScalarType.h
@@ -37,14 +37,14 @@
         KIND_DOUBLE,
     };
 
-    ScalarType(Kind kind);
+    ScalarType(Kind kind, Scope* parent);
 
     bool isScalar() const override;
 
     bool isElidableType() const override;
     const ScalarType *resolveToScalarType() const override;
 
-    bool canCheckEquality() const override;
+    bool deepCanCheckEquality(std::unordered_set<const Type*>* visited) const override;
 
     std::string typeName() const override;
     bool isValidEnumStorageType() const;
@@ -96,7 +96,7 @@
             const std::string &offset,
             bool isReader) const override;
 
-    status_t emitVtsTypeDeclarations(Formatter &out) const override;
+    void emitVtsTypeDeclarations(Formatter& out) const override;
 
     void getAlignmentAndSize(size_t *align, size_t *size) const override;
 
diff --git a/Scope.cpp b/Scope.cpp
index 13a6f28..bff097f 100644
--- a/Scope.cpp
+++ b/Scope.cpp
@@ -16,42 +16,44 @@
 
 #include "Scope.h"
 
+#include "Annotation.h"
+#include "ConstantExpression.h"
 #include "Interface.h"
 
 #include <android-base/logging.h>
 #include <hidl-util/Formatter.h>
+#include <hidl-util/StringHelper.h>
+#include <algorithm>
+#include <iostream>
 #include <vector>
 
 namespace android {
 
-Scope::Scope(const char* localName, const Location& location, Scope* parent)
-    : NamedType(localName, location, parent) {}
+Scope::Scope(const char* localName, const FQName& fullName, const Location& location, Scope* parent)
+    : NamedType(localName, fullName, location, parent) {}
 Scope::~Scope(){}
 
-bool Scope::addType(NamedType *type, std::string *errorMsg) {
-    const std::string &localName = type->localName();
-
-    auto it = mTypeIndexByName.find(localName);
-
-    if (it != mTypeIndexByName.end()) {
-        *errorMsg = "A type named '";
-        (*errorMsg) += localName;
-        (*errorMsg) += "' is already declared in the  current scope.";
-
-        return false;
-    }
-
+void Scope::addType(NamedType* type) {
     size_t index = mTypes.size();
     mTypes.push_back(type);
-    mTypeIndexByName[localName] = index;
+    mTypeIndexByName[type->localName()] = index;
+}
 
-    return true;
+status_t Scope::validateUniqueNames() const {
+    for (const auto* type : mTypes) {
+        if (mTypes[mTypeIndexByName.at(type->localName())] != type) {
+            std::cerr << "ERROR: A type named '" << type->localName()
+                      << "' is already declared in the scope at " << type->location() << std::endl;
+            return UNKNOWN_ERROR;
+        }
+    }
+    return OK;
 }
 
 NamedType *Scope::lookupType(const FQName &fqName) const {
     CHECK(fqName.package().empty() && fqName.version().empty());
     if (!fqName.valueName().empty()) {
-        LOG(WARNING) << fqName.string() << " does not refer to a type.";
+        std::cerr << "ERROR: " << fqName.string() << " does not refer to a type." << std::endl;
         return nullptr;
     }
     std::vector<std::string> names = fqName.names();
@@ -73,7 +75,8 @@
     Scope *outerScope = static_cast<Scope *>(outerType);
     // *slowly* pop first element
     names.erase(names.begin());
-    FQName innerName(names);
+    FQName innerName;
+    CHECK(FQName::parse(StringHelper::JoinStrings(names, "."), &innerName));
     return outerScope->lookupType(innerName);
 }
 
@@ -103,96 +106,144 @@
     return false;
 }
 
-status_t Scope::forEachType(std::function<status_t(Type *)> func) const {
-    for (size_t i = 0; i < mTypes.size(); ++i) {
-        status_t err = func(mTypes[i]);
+const std::vector<Annotation*>& Scope::annotations() const {
+    return mAnnotations;
+}
 
-        if (err != OK) {
-            return err;
-        }
+void Scope::setAnnotations(std::vector<Annotation*>* annotations) {
+    CHECK(mAnnotations.empty());
+    CHECK(annotations != nullptr);
+    mAnnotations = *annotations;
+}
+
+std::vector<const Type*> Scope::getDefinedTypes() const {
+    std::vector<const Type*> ret;
+    ret.insert(ret.end(), mTypes.begin(), mTypes.end());
+    return ret;
+}
+
+std::vector<const ConstantExpression*> Scope::getConstantExpressions() const {
+    std::vector<const ConstantExpression*> ret;
+    for (const auto* annotation : mAnnotations) {
+        const auto& retAnnotation = annotation->getConstantExpressions();
+        ret.insert(ret.end(), retAnnotation.begin(), retAnnotation.end());
+    }
+    return ret;
+}
+
+void Scope::topologicalReorder(const std::unordered_map<const Type*, size_t>& reversedOrder) {
+    auto less = [&](const Type* lhs, const Type* rhs) {
+        return reversedOrder.at(lhs) < reversedOrder.at(rhs);
+    };
+
+    if (std::is_sorted(mTypes.begin(), mTypes.end(), less)) return;
+
+    mTypeOrderChanged = true;
+    std::sort(mTypes.begin(), mTypes.end(), less);
+
+    for (size_t i = 0; i != mTypes.size(); ++i) {
+        mTypeIndexByName.at(mTypes[i]->localName()) = i;
+    }
+}
+
+void Scope::emitTypeDeclarations(Formatter& out) const {
+    if (mTypes.empty()) return;
+
+    out << "// Forward declaration for forward reference support:\n";
+    for (const Type* type : mTypes) {
+        type->emitTypeForwardDeclaration(out);
+    }
+    out << "\n";
+
+    if (mTypeOrderChanged) {
+        out << "// Order of inner types was changed for forward reference support.\n\n";
     }
 
-    return OK;
+    for (const Type* type : mTypes) {
+        type->emitDocComment(out);
+        type->emitTypeDeclarations(out);
+    }
 }
 
-status_t Scope::emitTypeDeclarations(Formatter &out) const {
-    return forEachType([&](Type *type) {
-        return type->emitTypeDeclarations(out);
-    });
+void Scope::emitGlobalTypeDeclarations(Formatter& out) const {
+    for (const Type* type : mTypes) {
+        type->emitGlobalTypeDeclarations(out);
+    }
 }
 
-status_t Scope::emitGlobalTypeDeclarations(Formatter &out) const {
-    return forEachType([&](Type *type) {
-        return type->emitGlobalTypeDeclarations(out);
-    });
+void Scope::emitPackageTypeDeclarations(Formatter& out) const {
+    for (const Type* type : mTypes) {
+        type->emitPackageTypeDeclarations(out);
+    }
 }
 
-status_t Scope::emitGlobalHwDeclarations(Formatter &out) const {
-    return forEachType([&](Type *type) {
-        return type->emitGlobalHwDeclarations(out);
-    });
+void Scope::emitPackageHwDeclarations(Formatter& out) const {
+    for (const Type* type : mTypes) {
+        type->emitPackageHwDeclarations(out);
+    }
 }
 
-status_t Scope::emitJavaTypeDeclarations(
-        Formatter &out, bool atTopLevel) const {
-    return forEachType([&](Type *type) {
-        return type->emitJavaTypeDeclarations(out, atTopLevel);
-    });
+void Scope::emitJavaTypeDeclarations(Formatter& out, bool atTopLevel) const {
+    if (mTypeOrderChanged) {
+        out << "// Order of inner types was changed for forward reference support.\n\n";
+    }
+
+    for (const Type* type : mTypes) {
+        type->emitDocComment(out);
+        type->emitJavaTypeDeclarations(out, atTopLevel);
+    }
 }
 
-status_t Scope::emitTypeDefinitions(
-        Formatter &out, const std::string prefix) const {
-    return forEachType([&](Type *type) {
-        return type->emitTypeDefinitions(out, prefix);
-    });
+void Scope::emitTypeDefinitions(Formatter& out, const std::string& prefix) const {
+    for (const Type* type : mTypes) {
+        type->emitTypeDefinitions(out, prefix);
+    }
 }
 
 const std::vector<NamedType *> &Scope::getSubTypes() const {
     return mTypes;
 }
 
-status_t Scope::emitVtsTypeDeclarations(Formatter &out) const {
-    return forEachType([&](Type *type) {
-        return type->emitVtsTypeDeclarations(out);
-    });
+void Scope::emitVtsTypeDeclarations(Formatter& out) const {
+    for (const Type* type : mTypes) {
+        type->emitVtsTypeDeclarations(out);
+    }
 }
 
-bool Scope::isJavaCompatible() const {
-    for (const auto &type : mTypes) {
-        if (!type->isJavaCompatible()) {
+bool Scope::deepIsJavaCompatible(std::unordered_set<const Type*>* visited) const {
+    for (const Type* type : mTypes) {
+        if (!type->isJavaCompatible(visited)) {
             return false;
         }
     }
-
-    return true;
-}
-
-bool Scope::containsPointer() const {
-    for (const auto &type : mTypes) {
-        if (type->containsPointer()) {
-            return true;
-        }
-    }
-
-    return false;
+    return Type::deepIsJavaCompatible(visited);
 }
 
 void Scope::appendToExportedTypesVector(
         std::vector<const Type *> *exportedTypes) const {
-    forEachType([&](Type *type) {
+    for (const Type* type : mTypes) {
         type->appendToExportedTypesVector(exportedTypes);
-        return OK;
-    });
+    }
 }
 
-RootScope::RootScope(const char* localName, const Location& location, Scope* parent)
-    : Scope(localName, location, parent) {}
+////////////////////////////////////////
+
+RootScope::RootScope(const char* localName, const FQName& fullName, const Location& location,
+                     Scope* parent)
+    : Scope(localName, fullName, location, parent) {}
 RootScope::~RootScope() {}
 
 std::string RootScope::typeName() const {
     return "(root scope)";
 }
 
+status_t RootScope::validate() const {
+    CHECK(annotations().empty());
+    return Scope::validate();
+}
+
+////////////////////////////////////////
+
 LocalIdentifier::LocalIdentifier(){}
 LocalIdentifier::~LocalIdentifier(){}
 
@@ -200,5 +251,17 @@
     return false;
 }
 
+const LocalIdentifier* LocalIdentifier::resolve() const {
+    return this;
+}
+
+LocalIdentifier* LocalIdentifier::resolve() {
+    return this;
+}
+
+ConstantExpression* LocalIdentifier::constExpr() const {
+    return nullptr;
+}
+
 }  // namespace android
 
diff --git a/Scope.h b/Scope.h
index 599182f..e8c9431 100644
--- a/Scope.h
+++ b/Scope.h
@@ -21,19 +21,24 @@
 #include "NamedType.h"
 
 #include <map>
+#include <unordered_map>
 #include <vector>
 
 namespace android {
 
+struct Annotation;
+struct ConstantExpression;
 struct Formatter;
 struct Interface;
 struct LocalIdentifier;
 
 struct Scope : public NamedType {
-    Scope(const char* localName, const Location& location, Scope* parent);
+    Scope(const char* localName, const FQName& fullName, const Location& location, Scope* parent);
     virtual ~Scope();
 
-    bool addType(NamedType *type, std::string *errorMsg);
+    void addType(NamedType* type);
+
+    status_t validateUniqueNames() const;
 
     // lookup a type given an FQName.
     // Assume fqName.package(), fqName.version(), fqName.valueName() is empty.
@@ -48,39 +53,51 @@
 
     bool containsInterfaces() const;
 
-    status_t emitTypeDeclarations(Formatter &out) const override;
-    status_t emitGlobalTypeDeclarations(Formatter &out) const override;
-    status_t emitGlobalHwDeclarations(Formatter &out) const override;
+    const std::vector<Annotation*>& annotations() const;
 
-    status_t emitJavaTypeDeclarations(
-            Formatter &out, bool atTopLevel) const override;
+    void setAnnotations(std::vector<Annotation*>* annotations);
 
-    status_t emitTypeDefinitions(
-            Formatter &out, const std::string prefix) const override;
+    std::vector<const Type*> getDefinedTypes() const override;
+
+    std::vector<const ConstantExpression*> getConstantExpressions() const override;
+
+    void topologicalReorder(const std::unordered_map<const Type*, size_t>& reversedOrder);
+
+    void emitTypeDeclarations(Formatter& out) const override;
+    void emitGlobalTypeDeclarations(Formatter& out) const override;
+    void emitPackageTypeDeclarations(Formatter& out) const override;
+    void emitPackageHwDeclarations(Formatter& out) const override;
+
+    void emitJavaTypeDeclarations(Formatter& out, bool atTopLevel) const override;
+
+    void emitTypeDefinitions(Formatter& out, const std::string& prefix) const override;
 
     const std::vector<NamedType *> &getSubTypes() const;
 
-    status_t emitVtsTypeDeclarations(Formatter &out) const override;
+    void emitVtsTypeDeclarations(Formatter& out) const override;
 
-    bool isJavaCompatible() const override;
-    bool containsPointer() const override;
+    bool deepIsJavaCompatible(std::unordered_set<const Type*>* visited) const override;
 
     void appendToExportedTypesVector(
             std::vector<const Type *> *exportedTypes) const override;
 
-private:
+   private:
     std::vector<NamedType *> mTypes;
     std::map<std::string, size_t> mTypeIndexByName;
+    std::vector<Annotation*> mAnnotations;
 
-    status_t forEachType(std::function<status_t(Type *)> func) const;
+    bool mTypeOrderChanged = false;
 
     DISALLOW_COPY_AND_ASSIGN(Scope);
 };
 
 struct RootScope : public Scope {
-    RootScope(const char* localName, const Location& location, Scope* parent);
+    RootScope(const char* localName, const FQName& fullName, const Location& location,
+              Scope* parent);
     virtual ~RootScope();
 
+    virtual status_t validate() const override;
+
     std::string typeName() const override;
 };
 
@@ -88,6 +105,11 @@
     LocalIdentifier();
     virtual ~LocalIdentifier();
     virtual bool isEnumValue() const;
+
+    const LocalIdentifier* resolve() const;
+    LocalIdentifier* resolve();
+
+    virtual ConstantExpression* constExpr() const;
 };
 
 }  // namespace android
diff --git a/StringType.cpp b/StringType.cpp
index 7a60277..a07086f 100644
--- a/StringType.cpp
+++ b/StringType.cpp
@@ -22,13 +22,13 @@
 
 namespace android {
 
-StringType::StringType() {}
+StringType::StringType(Scope* parent) : Type(parent) {}
 
 bool StringType::isString() const {
     return true;
 }
 
-bool StringType::canCheckEquality() const {
+bool StringType::deepCanCheckEquality(std::unordered_set<const Type*>* /* visited */) const {
     return true;
 }
 
@@ -209,9 +209,8 @@
     return true;
 }
 
-status_t StringType::emitVtsTypeDeclarations(Formatter &out) const {
+void StringType::emitVtsTypeDeclarations(Formatter& out) const {
     out << "type: " << getVtsType() << "\n";
-    return OK;
 }
 
 static HidlTypeAssertion assertion("hidl_string", 16 /* size */);
diff --git a/StringType.h b/StringType.h
index 36299f7..a4e3691 100644
--- a/StringType.h
+++ b/StringType.h
@@ -23,11 +23,11 @@
 namespace android {
 
 struct StringType : public Type {
-    StringType();
+    StringType(Scope* parent);
 
     bool isString() const override;
 
-    bool canCheckEquality() const override;
+    bool deepCanCheckEquality(std::unordered_set<const Type*>* visited) const override;
 
     std::string typeName() const override;
 
@@ -77,7 +77,7 @@
     bool needsEmbeddedReadWrite() const override;
     bool resultNeedsDeref() const override;
 
-    status_t emitVtsTypeDeclarations(Formatter &out) const override;
+    void emitVtsTypeDeclarations(Formatter& out) const override;
 
     void getAlignmentAndSize(size_t *align, size_t *size) const override;
 };
diff --git a/Type.cpp b/Type.cpp
index ea8df98..84be36f 100644
--- a/Type.cpp
+++ b/Type.cpp
@@ -16,28 +16,22 @@
 
 #include "Type.h"
 
-#include "Annotation.h"
+#include "ConstantExpression.h"
+#include "NamedType.h"
 #include "ScalarType.h"
+#include "Scope.h"
 
-#include <hidl-util/Formatter.h>
 #include <android-base/logging.h>
+#include <hidl-util/Formatter.h>
+#include <algorithm>
+#include <iostream>
 
 namespace android {
 
-Type::Type()
-    : mAnnotations(nullptr) {
-}
+Type::Type(Scope* parent) : mParent(parent) {}
 
 Type::~Type() {}
 
-void Type::setAnnotations(std::vector<Annotation *> *annotations) {
-    mAnnotations = annotations;
-}
-
-const std::vector<Annotation *> &Type::annotations() const {
-    return *mAnnotations;
-}
-
 bool Type::isScope() const {
     return false;
 }
@@ -102,6 +96,228 @@
     return false;
 }
 
+Type* Type::resolve() {
+    return const_cast<Type*>(static_cast<const Type*>(this)->resolve());
+}
+
+const Type* Type::resolve() const {
+    return this;
+}
+
+std::vector<Type*> Type::getDefinedTypes() {
+    const auto& constRet = static_cast<const Type*>(this)->getDefinedTypes();
+    std::vector<Type*> ret(constRet.size());
+    std::transform(constRet.begin(), constRet.end(), ret.begin(),
+                   [](const auto* type) { return const_cast<Type*>(type); });
+    return ret;
+}
+
+std::vector<const Type*> Type::getDefinedTypes() const {
+    return {};
+}
+
+std::vector<Reference<Type>*> Type::getReferences() {
+    const auto& constRet = static_cast<const Type*>(this)->getReferences();
+    std::vector<Reference<Type>*> ret(constRet.size());
+    std::transform(constRet.begin(), constRet.end(), ret.begin(),
+                   [](const auto* ref) { return const_cast<Reference<Type>*>(ref); });
+    return ret;
+}
+
+std::vector<const Reference<Type>*> Type::getReferences() const {
+    return {};
+}
+
+std::vector<ConstantExpression*> Type::getConstantExpressions() {
+    const auto& constRet = static_cast<const Type*>(this)->getConstantExpressions();
+    std::vector<ConstantExpression*> ret(constRet.size());
+    std::transform(constRet.begin(), constRet.end(), ret.begin(),
+                   [](const auto* ce) { return const_cast<ConstantExpression*>(ce); });
+    return ret;
+}
+
+std::vector<const ConstantExpression*> Type::getConstantExpressions() const {
+    return {};
+}
+
+std::vector<Reference<Type>*> Type::getStrongReferences() {
+    const auto& constRet = static_cast<const Type*>(this)->getStrongReferences();
+    std::vector<Reference<Type>*> ret(constRet.size());
+    std::transform(constRet.begin(), constRet.end(), ret.begin(),
+                   [](const auto* ref) { return const_cast<Reference<Type>*>(ref); });
+    return ret;
+}
+
+std::vector<const Reference<Type>*> Type::getStrongReferences() const {
+    std::vector<const Reference<Type>*> ret;
+    for (const auto* ref : getReferences()) {
+        if (!ref->shallowGet()->isNeverStrongReference()) {
+            ret.push_back(ref);
+        }
+    }
+    return ret;
+}
+
+status_t Type::recursivePass(const std::function<status_t(Type*)>& func,
+                             std::unordered_set<const Type*>* visited) {
+    if (mIsPostParseCompleted) return OK;
+
+    if (visited->find(this) != visited->end()) return OK;
+    visited->insert(this);
+
+    status_t err = func(this);
+    if (err != OK) return err;
+
+    for (auto* nextType : getDefinedTypes()) {
+        err = nextType->recursivePass(func, visited);
+        if (err != OK) return err;
+    }
+
+    for (auto* nextRef : getReferences()) {
+        err = nextRef->shallowGet()->recursivePass(func, visited);
+        if (err != OK) return err;
+    }
+
+    return OK;
+}
+
+status_t Type::recursivePass(const std::function<status_t(const Type*)>& func,
+                             std::unordered_set<const Type*>* visited) const {
+    if (mIsPostParseCompleted) return OK;
+
+    if (visited->find(this) != visited->end()) return OK;
+    visited->insert(this);
+
+    status_t err = func(this);
+    if (err != OK) return err;
+
+    for (const auto* nextType : getDefinedTypes()) {
+        err = nextType->recursivePass(func, visited);
+        if (err != OK) return err;
+    }
+
+    for (const auto* nextRef : getReferences()) {
+        err = nextRef->shallowGet()->recursivePass(func, visited);
+        if (err != OK) return err;
+    }
+
+    return OK;
+}
+
+status_t Type::resolveInheritance() {
+    return OK;
+}
+
+status_t Type::validate() const {
+    return OK;
+}
+
+Type::CheckAcyclicStatus::CheckAcyclicStatus(status_t status, const Type* cycleEnd)
+    : status(status), cycleEnd(cycleEnd) {
+    CHECK(cycleEnd == nullptr || status != OK);
+}
+
+Type::CheckAcyclicStatus Type::topologicalOrder(
+    std::unordered_map<const Type*, size_t>* reversedOrder,
+    std::unordered_set<const Type*>* stack) const {
+    if (stack->find(this) != stack->end()) {
+        std::cerr << "ERROR: Cyclic declaration:\n";
+        return CheckAcyclicStatus(UNKNOWN_ERROR, this);
+    }
+
+    if (reversedOrder->find(this) != reversedOrder->end()) return CheckAcyclicStatus(OK);
+    stack->insert(this);
+
+    for (const auto* nextType : getDefinedTypes()) {
+        auto err = nextType->topologicalOrder(reversedOrder, stack);
+
+        if (err.status != OK) {
+            if (err.cycleEnd == nullptr) return err;
+
+            std::cerr << "  '" << nextType->typeName() << "' in '" << typeName() << "'";
+            if (nextType->isNamedType()) {
+                std::cerr << " at " << static_cast<const NamedType*>(nextType)->location();
+            }
+            std::cerr << "\n";
+
+            if (err.cycleEnd == this) {
+                return CheckAcyclicStatus(err.status);
+            }
+            return err;
+        }
+    }
+
+    for (const auto* nextRef : getStrongReferences()) {
+        const auto* nextType = nextRef->shallowGet();
+        auto err = nextType->topologicalOrder(reversedOrder, stack);
+
+        if (err.status != OK) {
+            if (err.cycleEnd == nullptr) return err;
+
+            std::cerr << "  '" << nextType->typeName() << "' in '" << typeName() << "' at "
+                      << nextRef->location() << "\n";
+
+            if (err.cycleEnd == this) {
+                return CheckAcyclicStatus(err.status);
+            }
+            return err;
+        }
+    }
+
+    CHECK(stack->find(this) != stack->end());
+    stack->erase(this);
+
+    CHECK(reversedOrder->find(this) == reversedOrder->end());
+    // Do not call insert and size in one statement to not rely on
+    // evaluation order.
+    size_t index = reversedOrder->size();
+    reversedOrder->insert({this, index});
+
+    return CheckAcyclicStatus(OK);
+}
+
+status_t Type::checkForwardReferenceRestrictions(const Reference<Type>& ref) const {
+    const Location& refLoc = ref.location();
+    const Type* refType = ref.shallowGet();
+
+    // Not NamedTypes are avaiable everywhere.
+    // Only ArrayType and TemplatedType contain additional types in
+    // their reference (which is actually a part of type definition),
+    // so they are proceeded in this case.
+    //
+    // If we support named templated types one day, we will need to change
+    // this logic.
+    if (!refType->isNamedType()) {
+        for (const Reference<Type>* innerRef : refType->getReferences()) {
+            status_t err = checkForwardReferenceRestrictions(*innerRef);
+            if (err != OK) return err;
+        }
+        return OK;
+    }
+
+    const Location& typeLoc = static_cast<const NamedType*>(refType)->location();
+
+    // If referenced type is declared in another file or before reference,
+    // there is no forward reference here.
+    if (!Location::inSameFile(refLoc, typeLoc) ||
+        (!Location::intersect(refLoc, typeLoc) && typeLoc < refLoc)) {
+        return OK;
+    }
+
+    // Type must be declared somewhere in the current stack to make it
+    // available for forward referencing.
+    const Type* refTypeParent = refType->parent();
+    for (const Type* ancestor = this; ancestor != nullptr; ancestor = ancestor->parent()) {
+        if (ancestor == refTypeParent) return OK;
+    }
+
+    std::cerr << "ERROR: Forward reference of '" << refType->typeName() << "' at " << ref.location()
+              << " is not supported.\n"
+              << "C++ forward declaration doesn't support inner types.\n";
+
+    return UNKNOWN_ERROR;
+}
+
 const ScalarType *Type::resolveToScalarType() const {
     return NULL;
 }
@@ -121,9 +337,36 @@
 }
 
 bool Type::canCheckEquality() const {
+    std::unordered_set<const Type*> visited;
+    return canCheckEquality(&visited);
+}
+
+bool Type::canCheckEquality(std::unordered_set<const Type*>* visited) const {
+    // See isJavaCompatible for similar structure.
+    if (visited->find(this) != visited->end()) {
+        return true;
+    }
+    visited->insert(this);
+    return deepCanCheckEquality(visited);
+}
+
+bool Type::deepCanCheckEquality(std::unordered_set<const Type*>* /* visited */) const {
     return false;
 }
 
+void Type::setPostParseCompleted() {
+    CHECK(!mIsPostParseCompleted);
+    mIsPostParseCompleted = true;
+}
+
+Scope* Type::parent() {
+    return mParent;
+}
+
+const Scope* Type::parent() const {
+    return mParent;
+}
+
 std::string Type::getCppType(StorageMode, bool) const {
     CHECK(!"Should not be here");
     return std::string();
@@ -370,36 +613,43 @@
     handleError(out, mode);
 }
 
-status_t Type::emitTypeDeclarations(Formatter &) const {
-    return OK;
-}
+void Type::emitTypeDeclarations(Formatter&) const {}
 
-status_t Type::emitGlobalTypeDeclarations(Formatter &) const {
-    return OK;
-}
+void Type::emitTypeForwardDeclaration(Formatter&) const {}
 
-status_t Type::emitGlobalHwDeclarations(Formatter &) const {
-    return OK;
-}
+void Type::emitGlobalTypeDeclarations(Formatter&) const {}
 
-status_t Type::emitTypeDefinitions(
-        Formatter &, const std::string) const {
-    return OK;
-}
+void Type::emitPackageTypeDeclarations(Formatter&) const {}
 
-status_t Type::emitJavaTypeDeclarations(Formatter &, bool) const {
-    return OK;
-}
+void Type::emitPackageHwDeclarations(Formatter&) const {}
+
+void Type::emitTypeDefinitions(Formatter&, const std::string&) const {}
+
+void Type::emitJavaTypeDeclarations(Formatter&, bool) const {}
 
 bool Type::needsEmbeddedReadWrite() const {
     return false;
 }
 
-bool Type::needsResolveReferences() const {
+bool Type::resultNeedsDeref() const {
     return false;
 }
 
-bool Type::resultNeedsDeref() const {
+bool Type::needsResolveReferences() const {
+    std::unordered_set<const Type*> visited;
+    return needsResolveReferences(&visited);
+}
+
+bool Type::needsResolveReferences(std::unordered_set<const Type*>* visited) const {
+    // See isJavaCompatible for similar structure.
+    if (visited->find(this) != visited->end()) {
+        return false;
+    }
+    visited->insert(this);
+    return deepNeedsResolveReferences(visited);
+}
+
+bool Type::deepNeedsResolveReferences(std::unordered_set<const Type*>* /* visited */) const {
     return false;
 }
 
@@ -438,79 +688,124 @@
     out << ");\n";
 }
 
-status_t Type::emitVtsTypeDeclarations(Formatter &) const {
-    return OK;
-}
+void Type::emitVtsTypeDeclarations(Formatter&) const {}
 
-status_t Type::emitVtsAttributeType(Formatter &out) const {
-    return emitVtsTypeDeclarations(out);
+void Type::emitVtsAttributeType(Formatter& out) const {
+    emitVtsTypeDeclarations(out);
 }
 
 bool Type::isJavaCompatible() const {
+    std::unordered_set<const Type*> visited;
+    return isJavaCompatible(&visited);
+}
+
+bool Type::containsPointer() const {
+    std::unordered_set<const Type*> visited;
+    return containsPointer(&visited);
+}
+
+bool Type::isJavaCompatible(std::unordered_set<const Type*>* visited) const {
+    // We need to find al least one path from requested vertex
+    // to not java compatible.
+    // That means that if we have already visited some vertex,
+    // there is no need to determine whether it is java compatible
+    // (and we can assume that it is java compatible),
+    // as if not, the information about that would appear in the
+    // requested vertex through another path.
+    if (visited->find(this) != visited->end()) {
+        return true;
+    }
+    visited->insert(this);
+    return deepIsJavaCompatible(visited);
+}
+
+bool Type::containsPointer(std::unordered_set<const Type*>* visited) const {
+    // See isJavaCompatible for similar structure.
+    if (visited->find(this) != visited->end()) {
+        return false;
+    }
+    visited->insert(this);
+    return deepContainsPointer(visited);
+}
+
+bool Type::deepIsJavaCompatible(std::unordered_set<const Type*>* /* visited */) const {
     return true;
 }
 
+bool Type::deepContainsPointer(std::unordered_set<const Type*>* /* visited */) const {
+    return false;
+}
+
 void Type::getAlignmentAndSize(
         size_t * /* align */, size_t * /* size */) const {
     CHECK(!"Should not be here.");
 }
 
-bool Type::containsPointer() const {
-    return false;
-}
-
 void Type::appendToExportedTypesVector(
         std::vector<const Type *> * /* exportedTypes */) const {
 }
 
-status_t Type::emitExportedHeader(
-        Formatter & /* out */, bool /* forJava */) const {
-    return OK;
+void Type::emitExportedHeader(Formatter& /* out */, bool /* forJava */) const {}
+
+bool Type::isNeverStrongReference() const {
+    return false;
 }
 
 ////////////////////////////////////////
 
-TemplatedType::TemplatedType() : mElementType(nullptr) {
+TemplatedType::TemplatedType(Scope* parent) : Type(parent) {}
+
+std::string TemplatedType::typeName() const {
+    return templatedTypeName() + " of " + mElementType->typeName();
 }
 
-void TemplatedType::setElementType(Type *elementType) {
-    CHECK(mElementType == nullptr); // can only be set once.
-    CHECK(isCompatibleElementType(elementType));
+void TemplatedType::setElementType(const Reference<Type>& elementType) {
+    // can only be set once.
+    CHECK(mElementType.isEmptyReference());
+    CHECK(!elementType.isEmptyReference());
+
     mElementType = elementType;
 }
 
-Type *TemplatedType::getElementType() const {
-    return mElementType;
+const Type* TemplatedType::getElementType() const {
+    return mElementType.get();
 }
 
 bool TemplatedType::isTemplatedType() const {
     return true;
 }
 
-status_t TemplatedType::emitVtsTypeDeclarations(Formatter &out) const {
-    out << "type: " << getVtsType() << "\n";
-    out << getVtsValueName() << ": {\n";
-    out.indent();
-    status_t err = mElementType->emitVtsTypeDeclarations(out);
-    if (err != OK) {
-        return err;
-    }
-    out.unindent();
-    out << "}\n";
-    return OK;
+std::vector<const Reference<Type>*> TemplatedType::getReferences() const {
+    return {&mElementType};
 }
 
-status_t TemplatedType::emitVtsAttributeType(Formatter &out) const {
+status_t TemplatedType::validate() const {
+    if (!isCompatibleElementType(mElementType.get())) {
+        std::cerr << "ERROR: " << typeName() /* contains element type */
+                  << " is not supported at " << mElementType.location() << "\n";
+        return UNKNOWN_ERROR;
+    }
+
+    return Type::validate();
+}
+
+void TemplatedType::emitVtsTypeDeclarations(Formatter& out) const {
     out << "type: " << getVtsType() << "\n";
     out << getVtsValueName() << ": {\n";
     out.indent();
-    status_t status = mElementType->emitVtsAttributeType(out);
-    if (status != OK) {
-        return status;
-    }
+    mElementType->emitVtsTypeDeclarations(out);
     out.unindent();
     out << "}\n";
-    return OK;
 }
+
+void TemplatedType::emitVtsAttributeType(Formatter& out) const {
+    out << "type: " << getVtsType() << "\n";
+    out << getVtsValueName() << ": {\n";
+    out.indent();
+    mElementType->emitVtsAttributeType(out);
+    out.unindent();
+    out << "}\n";
+}
+
 }  // namespace android
 
diff --git a/Type.h b/Type.h
index 8e139d4..a0ed5bc 100644
--- a/Type.h
+++ b/Type.h
@@ -19,20 +19,26 @@
 #define TYPE_H_
 
 #include <android-base/macros.h>
-#include <string>
 #include <utils/Errors.h>
-#include <vector>
 #include <set>
+#include <string>
+#include <unordered_map>
+#include <unordered_set>
+#include <vector>
+
+#include "DocComment.h"
+#include "Reference.h"
 
 namespace android {
 
-struct Annotation;
+struct ConstantExpression;
 struct Formatter;
-struct ScalarType;
 struct FQName;
+struct ScalarType;
+struct Scope;
 
-struct Type {
-    Type();
+struct Type : DocCommentable {
+    Type(Scope* parent);
     virtual ~Type();
 
     virtual bool isArray() const;
@@ -52,13 +58,82 @@
     virtual bool isTypeDef() const;
     virtual bool isVector() const;
 
+    // Resolves the type by unwrapping typedefs
+    Type* resolve();
+    virtual const Type* resolve() const;
+
+    // All types defined in this type.
+    std::vector<Type*> getDefinedTypes();
+    virtual std::vector<const Type*> getDefinedTypes() const;
+
+    // All types referenced in this type.
+    std::vector<Reference<Type>*> getReferences();
+    virtual std::vector<const Reference<Type>*> getReferences() const;
+
+    // All constant expressions referenced in this type.
+    std::vector<ConstantExpression*> getConstantExpressions();
+    virtual std::vector<const ConstantExpression*> getConstantExpressions() const;
+
+    // All types referenced in this type that must have completed
+    // definiton before being referenced.
+    std::vector<Reference<Type>*> getStrongReferences();
+    virtual std::vector<const Reference<Type>*> getStrongReferences() const;
+
+    // Proceeds recursive pass
+    // Makes sure to visit each node only once.
+    status_t recursivePass(const std::function<status_t(Type*)>& func,
+                           std::unordered_set<const Type*>* visited);
+    status_t recursivePass(const std::function<status_t(const Type*)>& func,
+                           std::unordered_set<const Type*>* visited) const;
+
+    // Recursive tree pass that completes type declarations
+    // that depend on super types
+    virtual status_t resolveInheritance();
+
+    // Recursive tree pass that validates all type-related
+    // syntax restrictions
+    virtual status_t validate() const;
+
+    // Recursive tree pass checkAcyclic return type.
+    // Stores cycle end for nice error messages.
+    struct CheckAcyclicStatus {
+        CheckAcyclicStatus(status_t status, const Type* cycleEnd = nullptr);
+
+        status_t status;
+
+        // If a cycle is found, stores the end of cycle.
+        // While going back in recursion, this is used to stop printing the cycle.
+        const Type* cycleEnd;
+    };
+
+    // Recursive tree pass that ensures that type definitions and references
+    // are acyclic and builds reversed topological order of the types.
+    // If some cases allow using of incomplete types, these cases are to be
+    // declared in Type::getStrongReferences.
+    CheckAcyclicStatus topologicalOrder(std::unordered_map<const Type*, size_t>* reversedOrder,
+                                        std::unordered_set<const Type*>* stack) const;
+
+    // Checks following C++ restriction on forward declaration:
+    // inner struct could be forward declared only inside its parent.
+    status_t checkForwardReferenceRestrictions(const Reference<Type>& ref) const;
+
     virtual const ScalarType *resolveToScalarType() const;
 
     virtual std::string typeName() const = 0;
 
     bool isValidEnumStorageType() const;
     virtual bool isElidableType() const;
+
     virtual bool canCheckEquality() const;
+    bool canCheckEquality(std::unordered_set<const Type*>* visited) const;
+    virtual bool deepCanCheckEquality(std::unordered_set<const Type*>* visited) const;
+
+    // Marks that package proceeding is completed
+    // Post parse passes must be proceeded during owner package parsing
+    void setPostParseCompleted();
+
+    Scope* parent();
+    const Scope* parent() const;
 
     enum StorageMode {
         StorageMode_Stack,
@@ -176,47 +251,65 @@
             const std::string &offset,
             bool isReader) const;
 
-    virtual status_t emitTypeDeclarations(Formatter &out) const;
+    virtual void emitTypeDeclarations(Formatter& out) const;
+
+    virtual void emitGlobalTypeDeclarations(Formatter& out) const;
+
+    // Emit scope C++ forward declaration.
+    // There is no need to forward declare interfaces, as
+    // they are always declared in global scope in dedicated file.
+    virtual void emitTypeForwardDeclaration(Formatter& out) const;
 
     // Emit any declarations pertaining to this type that have to be
     // at global scope, i.e. enum class operators.
-    virtual status_t emitGlobalTypeDeclarations(Formatter &out) const;
+    // For android.hardware.foo@1.0::*, this will be in namespace
+    // android::hardware::foo::V1_0
+    virtual void emitPackageTypeDeclarations(Formatter& out) const;
 
     // Emit any declarations pertaining to this type that have to be
     // at global scope for transport, e.g. read/writeEmbeddedTo/FromParcel
-    virtual status_t emitGlobalHwDeclarations(Formatter &out) const;
+    // For android.hardware.foo@1.0::*, this will be in namespace
+    // android::hardware::foo::V1_0
+    virtual void emitPackageHwDeclarations(Formatter& out) const;
 
-    virtual status_t emitTypeDefinitions(
-            Formatter &out, const std::string prefix) const;
+    virtual void emitTypeDefinitions(Formatter& out, const std::string& prefix) const;
 
-    virtual status_t emitJavaTypeDeclarations(
-            Formatter &out, bool atTopLevel) const;
+    virtual void emitJavaTypeDeclarations(Formatter& out, bool atTopLevel) const;
 
     virtual bool needsEmbeddedReadWrite() const;
-    virtual bool needsResolveReferences() const;
     virtual bool resultNeedsDeref() const;
 
+    bool needsResolveReferences() const;
+    bool needsResolveReferences(std::unordered_set<const Type*>* visited) const;
+    virtual bool deepNeedsResolveReferences(std::unordered_set<const Type*>* visited) const;
+
     // Generates type declaration for vts proto file.
     // TODO (b/30844146): make it a pure virtual method.
-    virtual status_t emitVtsTypeDeclarations(Formatter &out) const;
+    virtual void emitVtsTypeDeclarations(Formatter& out) const;
     // Generates type declaration as attribute of method (return value or method
     // argument) or attribute of compound type for vts proto file.
-    virtual status_t emitVtsAttributeType(Formatter &out) const;
+    virtual void emitVtsAttributeType(Formatter& out) const;
 
     // Returns true iff this type is supported through the Java backend.
-    virtual bool isJavaCompatible() const;
-    virtual bool containsPointer() const;
-    virtual void getAlignmentAndSize(size_t *align, size_t *size) const;
+    bool isJavaCompatible() const;
+    bool isJavaCompatible(std::unordered_set<const Type*>* visited) const;
+    virtual bool deepIsJavaCompatible(std::unordered_set<const Type*>* visited) const;
+    // Returns true iff type contains pointer
+    // (excluding methods and inner types).
+    bool containsPointer() const;
+    bool containsPointer(std::unordered_set<const Type*>* visited) const;
+    virtual bool deepContainsPointer(std::unordered_set<const Type*>* visited) const;
 
-    void setAnnotations(std::vector<Annotation *> *annotations);
-    const std::vector<Annotation *> &annotations() const;
+    virtual void getAlignmentAndSize(size_t *align, size_t *size) const;
 
     virtual void appendToExportedTypesVector(
             std::vector<const Type *> *exportedTypes) const;
 
-    virtual status_t emitExportedHeader(Formatter &out, bool forJava) const;
+    virtual void emitExportedHeader(Formatter& out, bool forJava) const;
 
-protected:
+    virtual bool isNeverStrongReference() const;
+
+   protected:
     void handleError(Formatter &out, ErrorMode mode) const;
 
     void emitReaderWriterEmbeddedForTypeName(
@@ -247,24 +340,37 @@
             const std::string &methodName,
             const std::string &name) const;
 
-private:
-    std::vector<Annotation *> *mAnnotations;
+   private:
+    bool mIsPostParseCompleted = false;
+    Scope* const mParent;
 
     DISALLOW_COPY_AND_ASSIGN(Type);
 };
 
 /* Base type for VectorType and RefType. */
 struct TemplatedType : public Type {
-    void setElementType(Type *elementType);
-    Type *getElementType() const;
+    void setElementType(const Reference<Type>& elementType);
+    const Type* getElementType() const;
+
+    virtual std::string templatedTypeName() const = 0;
+    std::string typeName() const override;
+
     bool isTemplatedType() const override;
-    virtual bool isCompatibleElementType(Type *elementType) const = 0;
-    status_t emitVtsTypeDeclarations(Formatter &out) const override;
-    status_t emitVtsAttributeType(Formatter &out) const override;
-protected:
-    TemplatedType();
-    Type *mElementType;
-private:
+
+    virtual bool isCompatibleElementType(const Type* elementType) const = 0;
+
+    std::vector<const Reference<Type>*> getReferences() const override;
+
+    virtual status_t validate() const override;
+
+    void emitVtsTypeDeclarations(Formatter& out) const override;
+    void emitVtsAttributeType(Formatter& out) const override;
+
+   protected:
+    TemplatedType(Scope* parent);
+    Reference<Type> mElementType;
+
+   private:
     DISALLOW_COPY_AND_ASSIGN(TemplatedType);
 };
 
diff --git a/TypeDef.cpp b/TypeDef.cpp
index f419efe..dcefc57 100644
--- a/TypeDef.cpp
+++ b/TypeDef.cpp
@@ -21,16 +21,21 @@
 
 namespace android {
 
-TypeDef::TypeDef(const char* localName, const Location& location, Scope* parent, Type* type)
-    : NamedType(localName, location, parent), mReferencedType(type) {}
+TypeDef::TypeDef(const char* localName, const FQName& fullName, const Location& location,
+                 Scope* parent, const Reference<Type>& type)
+    : NamedType(localName, fullName, location, parent), mReferencedType(type) {}
 
 const ScalarType *TypeDef::resolveToScalarType() const {
     CHECK(!"Should not be here");
     return NULL;
 }
 
-Type *TypeDef::referencedType() const {
-    return mReferencedType;
+Type* TypeDef::referencedType() {
+    return mReferencedType.get();
+}
+
+const Type* TypeDef::referencedType() const {
+    return mReferencedType.get();
 }
 
 bool TypeDef::isInterface() const {
@@ -50,6 +55,14 @@
     return true;
 }
 
+const Type* TypeDef::resolve() const {
+    return mReferencedType.get();
+}
+
+std::vector<const Reference<Type>*> TypeDef::getReferences() const {
+    return {&mReferencedType};
+}
+
 bool TypeDef::needsEmbeddedReadWrite() const {
     CHECK(!"Should not be here");
     return false;
@@ -60,14 +73,12 @@
     return false;
 }
 
-status_t TypeDef::emitTypeDeclarations(Formatter &out) const {
+void TypeDef::emitTypeDeclarations(Formatter& out) const {
     out << "typedef "
         << mReferencedType->getCppStackType()
         << " "
         << localName()
         << ";\n\n";
-
-    return OK;
 }
 
 }  // namespace android
diff --git a/TypeDef.h b/TypeDef.h
index 7914363..5ebba3e 100644
--- a/TypeDef.h
+++ b/TypeDef.h
@@ -23,13 +23,15 @@
 namespace android {
 
 struct TypeDef : public NamedType {
-    TypeDef(const char* localName, const Location& location, Scope* parent, Type* type);
+    TypeDef(const char* localName, const FQName& fullName, const Location& location, Scope* parent,
+            const Reference<Type>& type);
 
     const ScalarType *resolveToScalarType() const override;
 
     std::string typeName() const override;
 
-    Type *referencedType() const;
+    Type* referencedType();
+    const Type* referencedType() const;
 
     bool isInterface() const override;
     bool isEnum() const override;
@@ -37,10 +39,14 @@
     bool needsEmbeddedReadWrite() const override;
     bool resultNeedsDeref() const override;
 
-    status_t emitTypeDeclarations(Formatter &out) const override;
+    const Type* resolve() const override;
 
-private:
-    Type *mReferencedType;
+    std::vector<const Reference<Type>*> getReferences() const override;
+
+    void emitTypeDeclarations(Formatter& out) const override;
+
+   private:
+    Reference<Type> mReferencedType;
 
     DISALLOW_COPY_AND_ASSIGN(TypeDef);
 };
diff --git a/VectorType.cpp b/VectorType.cpp
index 4d1dae8..03604dc 100644
--- a/VectorType.cpp
+++ b/VectorType.cpp
@@ -25,14 +25,13 @@
 
 namespace android {
 
-VectorType::VectorType() {
+VectorType::VectorType(Scope* parent) : TemplatedType(parent) {}
+
+std::string VectorType::templatedTypeName() const {
+    return "vector";
 }
 
-std::string VectorType::typeName() const {
-    return "vector" + (mElementType == nullptr ? "" : (" of " + mElementType->typeName()));
-}
-
-bool VectorType::isCompatibleElementType(Type *elementType) const {
+bool VectorType::isCompatibleElementType(const Type* elementType) const {
     if (elementType->isScalar()) {
         return true;
     }
@@ -45,8 +44,7 @@
     if (elementType->isBitField()) {
         return true;
     }
-    if (elementType->isCompoundType()
-            && static_cast<CompoundType *>(elementType)->style() == CompoundType::STYLE_STRUCT) {
+    if (elementType->isCompoundType()) {
         return true;
     }
     if (elementType->isInterface()) {
@@ -59,11 +57,11 @@
         return true;
     }
     if (elementType->isTemplatedType()) {
-        Type *inner = static_cast<TemplatedType *>(elementType)->getElementType();
+        const Type* inner = static_cast<const TemplatedType*>(elementType)->getElementType();
         return this->isCompatibleElementType(inner) && !inner->isInterface();
     }
     if (elementType->isArray()) {
-        Type *inner = static_cast<ArrayType *>(elementType)->getElementType();
+        const Type* inner = static_cast<const ArrayType*>(elementType)->getElementType();
         return this->isCompatibleElementType(inner) && !inner->isInterface();
     }
     return false;
@@ -77,8 +75,12 @@
     return mElementType->isBinder();
 }
 
-bool VectorType::canCheckEquality() const {
-    return mElementType->canCheckEquality();
+bool VectorType::deepCanCheckEquality(std::unordered_set<const Type*>* visited) const {
+    return mElementType->canCheckEquality(visited);
+}
+
+std::vector<const Reference<Type>*> VectorType::getStrongReferences() const {
+    return {};
 }
 
 std::string VectorType::getCppType(StorageMode mode,
@@ -564,7 +566,7 @@
     VectorType::EmitJavaFieldReaderWriterForElementType(
             out,
             depth,
-            mElementType,
+            mElementType.get(),
             parcelName,
             blobName,
             fieldName,
@@ -711,21 +713,24 @@
     return true;
 }
 
-bool VectorType::needsResolveReferences() const {
-    return mElementType->needsResolveReferences();
+bool VectorType::deepNeedsResolveReferences(std::unordered_set<const Type*>* visited) const {
+    if (mElementType->needsResolveReferences(visited)) {
+        return true;
+    }
+    return TemplatedType::deepNeedsResolveReferences(visited);
 }
 
 bool VectorType::resultNeedsDeref() const {
     return !isVectorOfBinders();
 }
 
-bool VectorType::isJavaCompatible() const {
-    if (!mElementType->isJavaCompatible()) {
+bool VectorType::deepIsJavaCompatible(std::unordered_set<const Type*>* visited) const {
+    if (!mElementType->isJavaCompatible(visited)) {
         return false;
     }
 
     if (mElementType->isArray()) {
-        return static_cast<ArrayType *>(mElementType)->countDimensions() == 1;
+        return static_cast<const ArrayType*>(mElementType.get())->countDimensions() == 1;
     }
 
     if (mElementType->isVector()) {
@@ -736,11 +741,14 @@
         return false;
     }
 
-    return true;
+    return TemplatedType::deepIsJavaCompatible(visited);
 }
 
-bool VectorType::containsPointer() const {
-    return mElementType->containsPointer();
+bool VectorType::deepContainsPointer(std::unordered_set<const Type*>* visited) const {
+    if (mElementType->containsPointer(visited)) {
+        return true;
+    }
+    return TemplatedType::deepContainsPointer(visited);
 }
 
 // All hidl_vec<T> have the same size.
diff --git a/VectorType.h b/VectorType.h
index e868355..6f6ede7 100644
--- a/VectorType.h
+++ b/VectorType.h
@@ -18,19 +18,25 @@
 
 #define VECTOR_TYPE_H_
 
+#include <vector>
+
+#include "Reference.h"
 #include "Type.h"
 
 namespace android {
 
 struct VectorType : public TemplatedType {
-    VectorType();
+    VectorType(Scope* parent);
 
     bool isVector() const override;
     bool isVectorOfBinders() const;
-    std::string typeName() const override;
-    bool isCompatibleElementType(Type *elementType) const override;
 
-    bool canCheckEquality() const override;
+    std::string templatedTypeName() const override;
+    bool isCompatibleElementType(const Type* elementType) const override;
+
+    std::vector<const Reference<Type>*> getStrongReferences() const override;
+
+    bool deepCanCheckEquality(std::unordered_set<const Type*>* visited) const override;
 
     std::string getCppType(
             StorageMode mode,
@@ -115,11 +121,11 @@
             bool isReader);
 
     bool needsEmbeddedReadWrite() const override;
-    bool needsResolveReferences() const override;
+    bool deepNeedsResolveReferences(std::unordered_set<const Type*>* visited) const override;
     bool resultNeedsDeref() const override;
 
-    bool isJavaCompatible() const override;
-    bool containsPointer() const override;
+    bool deepIsJavaCompatible(std::unordered_set<const Type*>* visited) const override;
+    bool deepContainsPointer(std::unordered_set<const Type*>* visited) const override;
 
     void getAlignmentAndSize(size_t *align, size_t *size) const override;
     static void getAlignmentAndSizeStatic(size_t *align, size_t *size);
diff --git a/build/Android.bp b/build/Android.bp
new file mode 100644
index 0000000..9b290a3
--- /dev/null
+++ b/build/Android.bp
@@ -0,0 +1,34 @@
+// Copyright (C) 2017 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.
+
+bootstrap_go_package {
+    name: "hidl-soong-rules",
+    pkgPath: "android/soong/hidl",
+    deps: [
+        "blueprint",
+        "soong",
+        "soong-android",
+        "soong-cc",
+        "soong-genrule",
+        "soong-java",
+    ],
+    srcs: [
+        "fqName.go",
+        "hidl_interface.go",
+        "hidl_package_root.go",
+        "properties.go",
+        "utils.go",
+    ],
+    pluginFor: ["soong_build"],
+}
diff --git a/build/fqName.go b/build/fqName.go
new file mode 100644
index 0000000..88f7dc0
--- /dev/null
+++ b/build/fqName.go
@@ -0,0 +1,126 @@
+// Copyright (C) 2017 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.
+
+package hidl
+
+import (
+	"errors"
+	"path/filepath"
+	"regexp"
+	"strings"
+)
+
+type fqName struct {
+	packageComponents []string
+	minor             string
+	major             string
+}
+
+// See system/tools/hidl/FQName.h
+var component = "[a-zA-Z_][a-zA-Z_0-9]*"
+var pkg = "(" + component + "(?:[.]" + component + ")*)"
+var digits = "([0-9]+)"
+var re_package = regexp.MustCompile("^" + pkg + "@" + digits + "." + digits + "$")
+
+func parseFqName(f string) (*fqName, error) {
+	matches := re_package.FindAllStringSubmatch(f, 3)
+
+	if matches == nil {
+		return nil, errors.New("Poorly formed hal interface name: '" + f + "' must match '" + re_package.String() + "'")
+	}
+
+	ret := fqName{
+		packageComponents: strings.Split(matches[0][1], "."),
+		major:             matches[0][2],
+		minor:             matches[0][3],
+	}
+
+	return &ret, nil
+}
+
+func (f *fqName) inPackage(pkg string) bool {
+	components := strings.Split(pkg, ".")
+
+	if len(components) > len(f.packageComponents) {
+		return false
+	}
+
+	for i, v := range components {
+		if f.packageComponents[i] != v {
+			return false
+		}
+	}
+
+	return true
+}
+
+func (f *fqName) pkg() string {
+	return strings.Join(f.packageComponents, ".")
+}
+func (f *fqName) version() string {
+	return f.major + "." + f.minor
+}
+func (f *fqName) sanitizedVersion() string {
+	return "V" + f.major + "_" + f.minor
+}
+func (f *fqName) string() string {
+	return f.pkg() + "@" + f.version()
+}
+func (f *fqName) sanitizedString() string {
+	return f.pkg() + "-V" + f.version() // NOT sanitizedVersion
+}
+
+func (f *fqName) dir() string {
+	return filepath.Join(filepath.Join(f.packageComponents...), f.version()) + "/"
+}
+func (f *fqName) sanitizedDir() string {
+	return filepath.Join(filepath.Join(f.packageComponents...), f.sanitizedVersion()) + "/"
+}
+
+func (f *fqName) fileGroupName() string {
+	return f.string() + "_hal"
+}
+func (f *fqName) sourcesName() string {
+	return f.string() + "_genc++"
+}
+func (f *fqName) headersName() string {
+	return f.string() + "_genc++_headers"
+}
+func (f *fqName) javaName() string {
+	return f.sanitizedString() + "-java"
+}
+func (f *fqName) javaSourcesName() string {
+	return f.sanitizedString() + "-java_gen_java"
+}
+func (f *fqName) javaConstantsName() string {
+	return f.sanitizedString() + "-java-constants"
+}
+func (f *fqName) javaConstantsSourcesName() string {
+	return f.sanitizedString() + "-java-constants_gen_java"
+}
+func (f *fqName) adapterName() string {
+	return f.string() + "-adapter"
+}
+func (f *fqName) adapterSourcesName() string {
+	return f.string() + "-adapter_genc++"
+}
+func (f *fqName) adapterHelperName() string {
+	return f.string() + "-adapter-helper"
+}
+func (f *fqName) adapterHelperSourcesName() string {
+	return f.string() + "-adapter-helper_genc++"
+}
+func (f *fqName) adapterHelperHeadersName() string {
+	return f.string() + "-adapter-helper_genc++_headers"
+}
diff --git a/build/hidl_interface.go b/build/hidl_interface.go
new file mode 100644
index 0000000..55cba94
--- /dev/null
+++ b/build/hidl_interface.go
@@ -0,0 +1,428 @@
+// Copyright (C) 2017 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.
+
+package hidl
+
+import (
+	"strings"
+	"sync"
+
+	"github.com/google/blueprint/proptools"
+
+	"android/soong/android"
+	"android/soong/cc"
+	"android/soong/genrule"
+	"android/soong/java"
+)
+
+var (
+	hidlInterfaceSuffix = "_interface"
+)
+
+func init() {
+	android.RegisterModuleType("hidl_interface", hidlInterfaceFactory)
+}
+
+type hidlInterfaceProperties struct {
+	// Vndk properties for interface library only.
+	cc.VndkProperties
+
+	// The owner of the module
+	Owner *string
+
+	// List of .hal files which compose this interface.
+	Srcs []string
+
+	// List of hal interface packages that this library depends on.
+	Interfaces []string
+
+	// Package root for this package, must be a prefix of name
+	Root string
+
+	// List of non-TypeDef types declared in types.hal.
+	Types []string
+
+	// Whether to generate the Java library stubs.
+	// Default: true
+	Gen_java *bool
+
+	// Whether to generate a Java library containing constants
+	// expressed by @export annotations in the hal files.
+	Gen_java_constants bool
+
+	// Don't generate "android.hidl.foo@1.0" C library. Instead
+	// only generate the genrules so that this package can be
+	// included in libhidltransport.
+	Core_interface bool
+}
+
+type hidlInterface struct {
+	android.ModuleBase
+
+	properties hidlInterfaceProperties
+}
+
+func processSources(mctx android.LoadHookContext, srcs []string) ([]string, []string, bool) {
+	var interfaces []string
+	var types []string // hidl-gen only supports types.hal, but don't assume that here
+
+	hasError := false
+
+	for _, v := range srcs {
+		if !strings.HasSuffix(v, ".hal") {
+			mctx.PropertyErrorf("srcs", "Source must be a .hal file: "+v)
+			hasError = true
+			continue
+		}
+
+		name := strings.TrimSuffix(v, ".hal")
+
+		if strings.HasPrefix(name, "I") {
+			baseName := strings.TrimPrefix(name, "I")
+			interfaces = append(interfaces, baseName)
+		} else {
+			types = append(types, name)
+		}
+	}
+
+	return interfaces, types, !hasError
+}
+
+func processDependencies(mctx android.LoadHookContext, interfaces []string) ([]string, []string, bool) {
+	var dependencies []string
+	var javaDependencies []string
+
+	hasError := false
+
+	for _, v := range interfaces {
+		name, err := parseFqName(v)
+		if err != nil {
+			mctx.PropertyErrorf("interfaces", err.Error())
+			hasError = true
+			continue
+		}
+		dependencies = append(dependencies, name.string())
+		javaDependencies = append(javaDependencies, name.javaName())
+	}
+
+	return dependencies, javaDependencies, !hasError
+}
+
+func getRootList(mctx android.LoadHookContext, interfaces []string) ([]string, bool) {
+	var roots []string
+	hasError := false
+
+	for _, i := range interfaces {
+		interfaceObject := lookupInterface(i)
+		if interfaceObject == nil {
+			mctx.PropertyErrorf("interfaces", "Cannot find interface "+i)
+			hasError = true
+			continue
+		}
+		root := interfaceObject.properties.Root
+		rootObject := lookupPackageRoot(root)
+		if rootObject == nil {
+			mctx.PropertyErrorf("interfaces", `Cannot find package root specification for package `+
+				`root '%s' needed for module '%s'. Either this is a mispelling of the package `+
+				`root, or a new hidl_package_root module needs to be added. For example, you can `+
+				`fix this error by adding the following to <some path>/Android.bp:
+
+hidl_package_root {
+    name: "%s",
+    path: "<some path>",
+}
+
+This corresponds to the "-r%s:<some path>" option that would be passed into hidl-gen.`, root, i, root, root)
+			hasError = true
+			continue
+		}
+
+		roots = append(roots, root+":"+rootObject.properties.Path)
+	}
+
+	return android.FirstUniqueStrings(roots), !hasError
+}
+
+func removeCoreDependencies(mctx android.LoadHookContext, dependencies []string) ([]string, bool) {
+	var ret []string
+	hasError := false
+
+	for _, i := range dependencies {
+		interfaceObject := lookupInterface(i)
+		if interfaceObject == nil {
+			mctx.PropertyErrorf("interfaces", "Cannot find interface "+i)
+			hasError = true
+			continue
+		}
+
+		if !interfaceObject.properties.Core_interface {
+			ret = append(ret, i)
+		}
+	}
+
+	return ret, !hasError
+}
+
+func hidlGenCommand(lang string, roots []string, name *fqName) *string {
+	cmd := "$(location hidl-gen) -d $(depfile) -o $(genDir)"
+	cmd += " -L" + lang
+	cmd += " " + strings.Join(wrap("-r", roots, ""), " ")
+	cmd += " " + name.string()
+	return &cmd
+}
+
+func hidlInterfaceMutator(mctx android.LoadHookContext, i *hidlInterface) {
+	name, err := parseFqName(i.ModuleBase.Name())
+	if err != nil {
+		mctx.PropertyErrorf("name", err.Error())
+	}
+
+	if !name.inPackage(i.properties.Root) {
+		mctx.PropertyErrorf("root", "Root, "+i.properties.Root+", for "+name.string()+" must be a prefix.")
+	}
+
+	interfaces, types, _ := processSources(mctx, i.properties.Srcs)
+
+	if len(interfaces) == 0 && len(types) == 0 {
+		mctx.PropertyErrorf("srcs", "No sources provided.")
+	}
+
+	dependencies, javaDependencies, _ := processDependencies(mctx, i.properties.Interfaces)
+	roots, _ := getRootList(mctx, append(dependencies, name.string()))
+	cppDependencies, _ := removeCoreDependencies(mctx, dependencies)
+
+	if mctx.Failed() {
+		return
+	}
+
+	shouldGenerateLibrary := !i.properties.Core_interface
+	// explicitly true if not specified to give early warning to devs
+	shouldGenerateJava := i.properties.Gen_java == nil || *i.properties.Gen_java
+	shouldGenerateJavaConstants := i.properties.Gen_java_constants
+
+	var libraryIfExists []string
+	if shouldGenerateLibrary {
+		libraryIfExists = []string{name.string()}
+	}
+
+	// TODO(b/69002743): remove filegroups
+	mctx.CreateModule(android.ModuleFactoryAdaptor(genrule.FileGroupFactory), &fileGroupProperties{
+		Name:  proptools.StringPtr(name.fileGroupName()),
+		Owner: i.properties.Owner,
+		Srcs:  i.properties.Srcs,
+	})
+
+	mctx.CreateModule(android.ModuleFactoryAdaptor(genrule.GenRuleFactory), &genruleProperties{
+		Name:    proptools.StringPtr(name.sourcesName()),
+		Depfile: proptools.BoolPtr(true),
+		Owner:   i.properties.Owner,
+		Tools:   []string{"hidl-gen"},
+		Cmd:     hidlGenCommand("c++-sources", roots, name),
+		Srcs:    i.properties.Srcs,
+		Out: concat(wrap(name.dir(), interfaces, "All.cpp"),
+			wrap(name.dir(), types, ".cpp")),
+	})
+	mctx.CreateModule(android.ModuleFactoryAdaptor(genrule.GenRuleFactory), &genruleProperties{
+		Name:    proptools.StringPtr(name.headersName()),
+		Depfile: proptools.BoolPtr(true),
+		Owner:   i.properties.Owner,
+		Tools:   []string{"hidl-gen"},
+		Cmd:     hidlGenCommand("c++-headers", roots, name),
+		Srcs:    i.properties.Srcs,
+		Out: concat(wrap(name.dir()+"I", interfaces, ".h"),
+			wrap(name.dir()+"Bs", interfaces, ".h"),
+			wrap(name.dir()+"BnHw", interfaces, ".h"),
+			wrap(name.dir()+"BpHw", interfaces, ".h"),
+			wrap(name.dir()+"IHw", interfaces, ".h"),
+			wrap(name.dir(), types, ".h"),
+			wrap(name.dir()+"hw", types, ".h")),
+	})
+
+	if shouldGenerateLibrary {
+		mctx.CreateModule(android.ModuleFactoryAdaptor(cc.LibraryFactory), &ccProperties{
+			Name:              proptools.StringPtr(name.string()),
+			Owner:             i.properties.Owner,
+			Vendor_available:  proptools.BoolPtr(true),
+			Defaults:          []string{"hidl-module-defaults"},
+			Generated_sources: []string{name.sourcesName()},
+			Generated_headers: []string{name.headersName()},
+			Shared_libs: concat(cppDependencies, []string{
+				"libhidlbase",
+				"libhidltransport",
+				"libhwbinder",
+				"liblog",
+				"libutils",
+				"libcutils",
+			}),
+			Export_shared_lib_headers: concat(cppDependencies, []string{
+				"libhidlbase",
+				"libhidltransport",
+				"libhwbinder",
+				"libutils",
+			}),
+			Export_generated_headers: []string{name.headersName()},
+		}, &i.properties.VndkProperties)
+	}
+
+	if shouldGenerateJava {
+		mctx.CreateModule(android.ModuleFactoryAdaptor(genrule.GenRuleFactory), &genruleProperties{
+			Name:    proptools.StringPtr(name.javaSourcesName()),
+			Depfile: proptools.BoolPtr(true),
+			Owner:   i.properties.Owner,
+			Tools:   []string{"hidl-gen"},
+			Cmd:     hidlGenCommand("java", roots, name),
+			Srcs:    i.properties.Srcs,
+			Out: concat(wrap(name.sanitizedDir()+"I", interfaces, ".java"),
+				wrap(name.sanitizedDir(), i.properties.Types, ".java")),
+		})
+		mctx.CreateModule(android.ModuleFactoryAdaptor(java.LibraryFactory(true)), &javaProperties{
+			Name:              proptools.StringPtr(name.javaName()),
+			Owner:             i.properties.Owner,
+			Sdk_version:       proptools.StringPtr("system_current"),
+			Defaults:          []string{"hidl-java-module-defaults"},
+			No_framework_libs: proptools.BoolPtr(true),
+			Srcs:              []string{":" + name.javaSourcesName()},
+			Static_libs:       append(javaDependencies, "hwbinder"),
+		})
+	}
+
+	if shouldGenerateJavaConstants {
+		mctx.CreateModule(android.ModuleFactoryAdaptor(genrule.GenRuleFactory), &genruleProperties{
+			Name:    proptools.StringPtr(name.javaConstantsSourcesName()),
+			Depfile: proptools.BoolPtr(true),
+			Owner:   i.properties.Owner,
+			Tools:   []string{"hidl-gen"},
+			Cmd:     hidlGenCommand("java-constants", roots, name),
+			Srcs:    i.properties.Srcs,
+			Out:     []string{name.sanitizedDir() + "Constants.java"},
+		})
+		mctx.CreateModule(android.ModuleFactoryAdaptor(java.LibraryFactory(true)), &javaProperties{
+			Name:              proptools.StringPtr(name.javaConstantsName()),
+			Owner:             i.properties.Owner,
+			Defaults:          []string{"hidl-java-module-defaults"},
+			No_framework_libs: proptools.BoolPtr(true),
+			Srcs:              []string{":" + name.javaConstantsSourcesName()},
+		})
+	}
+
+	mctx.CreateModule(android.ModuleFactoryAdaptor(genrule.GenRuleFactory), &genruleProperties{
+		Name:    proptools.StringPtr(name.adapterHelperSourcesName()),
+		Depfile: proptools.BoolPtr(true),
+		Owner:   i.properties.Owner,
+		Tools:   []string{"hidl-gen"},
+		Cmd:     hidlGenCommand("c++-adapter-sources", roots, name),
+		Srcs:    i.properties.Srcs,
+		Out:     wrap(name.dir()+"A", concat(interfaces, types), ".cpp"),
+	})
+	mctx.CreateModule(android.ModuleFactoryAdaptor(genrule.GenRuleFactory), &genruleProperties{
+		Name:    proptools.StringPtr(name.adapterHelperHeadersName()),
+		Depfile: proptools.BoolPtr(true),
+		Owner:   i.properties.Owner,
+		Tools:   []string{"hidl-gen"},
+		Cmd:     hidlGenCommand("c++-adapter-headers", roots, name),
+		Srcs:    i.properties.Srcs,
+		Out:     wrap(name.dir()+"A", concat(interfaces, types), ".h"),
+	})
+
+	mctx.CreateModule(android.ModuleFactoryAdaptor(cc.LibraryFactory), &ccProperties{
+		Name:              proptools.StringPtr(name.adapterHelperName()),
+		Owner:             i.properties.Owner,
+		Vendor_available:  proptools.BoolPtr(true),
+		Defaults:          []string{"hidl-module-defaults"},
+		Generated_sources: []string{name.adapterHelperSourcesName()},
+		Generated_headers: []string{name.adapterHelperHeadersName()},
+		Shared_libs: []string{
+			"libbase",
+			"libcutils",
+			"libhidlbase",
+			"libhidltransport",
+			"libhwbinder",
+			"liblog",
+			"libutils",
+		},
+		Static_libs: concat([]string{
+			"libhidladapter",
+		}, wrap("", dependencies, "-adapter-helper"), cppDependencies, libraryIfExists),
+		Export_shared_lib_headers: []string{
+			"libhidlbase",
+			"libhidltransport",
+		},
+		Export_static_lib_headers: concat([]string{
+			"libhidladapter",
+		}, wrap("", dependencies, "-adapter-helper"), cppDependencies, libraryIfExists),
+		Export_generated_headers: []string{name.adapterHelperHeadersName()},
+		Group_static_libs:        proptools.BoolPtr(true),
+	})
+	mctx.CreateModule(android.ModuleFactoryAdaptor(genrule.GenRuleFactory), &genruleProperties{
+		Name:    proptools.StringPtr(name.adapterSourcesName()),
+		Depfile: proptools.BoolPtr(true),
+		Owner:   i.properties.Owner,
+		Tools:   []string{"hidl-gen"},
+		Cmd:     hidlGenCommand("c++-adapter-main", roots, name),
+		Srcs:    i.properties.Srcs,
+		Out:     []string{"main.cpp"},
+	})
+	mctx.CreateModule(android.ModuleFactoryAdaptor(cc.TestFactory), &ccProperties{
+		Name:              proptools.StringPtr(name.adapterName()),
+		Owner:             i.properties.Owner,
+		Generated_sources: []string{name.adapterSourcesName()},
+		Shared_libs: []string{
+			"libbase",
+			"libcutils",
+			"libhidlbase",
+			"libhidltransport",
+			"libhwbinder",
+			"liblog",
+			"libutils",
+		},
+		Static_libs: concat([]string{
+			"libhidladapter",
+			name.adapterHelperName(),
+		}, wrap("", dependencies, "-adapter-helper"), cppDependencies, libraryIfExists),
+		Group_static_libs: proptools.BoolPtr(true),
+	})
+}
+
+func (h *hidlInterface) Name() string {
+	return h.ModuleBase.Name() + hidlInterfaceSuffix
+}
+func (h *hidlInterface) GenerateAndroidBuildActions(ctx android.ModuleContext) {
+}
+func (h *hidlInterface) DepsMutator(ctx android.BottomUpMutatorContext) {
+}
+
+var hidlInterfaceMutex sync.Mutex
+var hidlInterfaces []*hidlInterface
+
+func hidlInterfaceFactory() android.Module {
+	i := &hidlInterface{}
+	i.AddProperties(&i.properties)
+	android.InitAndroidModule(i)
+	android.AddLoadHook(i, func(ctx android.LoadHookContext) { hidlInterfaceMutator(ctx, i) })
+
+	hidlInterfaceMutex.Lock()
+	hidlInterfaces = append(hidlInterfaces, i)
+	hidlInterfaceMutex.Unlock()
+
+	return i
+}
+
+func lookupInterface(name string) *hidlInterface {
+	for _, i := range hidlInterfaces {
+		if i.ModuleBase.Name() == name {
+			return i
+		}
+	}
+	return nil
+}
diff --git a/build/hidl_package_root.go b/build/hidl_package_root.go
new file mode 100644
index 0000000..1f68af4
--- /dev/null
+++ b/build/hidl_package_root.go
@@ -0,0 +1,63 @@
+// Copyright (C) 2017 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.
+
+package hidl
+
+import (
+	"sync"
+
+	"android/soong/android"
+)
+
+func init() {
+	android.RegisterModuleType("hidl_package_root", hidlPackageRootFactory)
+}
+
+type hidlPackageRoot struct {
+	android.ModuleBase
+
+	properties struct {
+		// path to this module from root
+		Path string
+	}
+}
+
+func (r *hidlPackageRoot) GenerateAndroidBuildActions(ctx android.ModuleContext) {
+}
+func (r *hidlPackageRoot) DepsMutator(ctx android.BottomUpMutatorContext) {
+}
+
+var packageRootsMutex sync.Mutex
+var packageRoots []*hidlPackageRoot
+
+func hidlPackageRootFactory() android.Module {
+	r := &hidlPackageRoot{}
+	r.AddProperties(&r.properties)
+	android.InitAndroidModule(r)
+
+	packageRootsMutex.Lock()
+	packageRoots = append(packageRoots, r)
+	packageRootsMutex.Unlock()
+
+	return r
+}
+
+func lookupPackageRoot(name string) *hidlPackageRoot {
+	for _, i := range packageRoots {
+		if i.ModuleBase.Name() == name {
+			return i
+		}
+	}
+	return nil
+}
diff --git a/build/properties.go b/build/properties.go
new file mode 100644
index 0000000..d2f8a35
--- /dev/null
+++ b/build/properties.go
@@ -0,0 +1,61 @@
+// Copyright (C) 2017 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.
+
+package hidl
+
+type nameProperties struct {
+	Name *string
+}
+
+type fileGroupProperties struct {
+	Name  *string
+	Owner *string
+	Srcs  []string
+}
+
+type genruleProperties struct {
+	Name    *string
+	Owner   *string
+	Tools   []string
+	Cmd     *string
+	Srcs    []string
+	Out     []string
+	Depfile *bool
+}
+
+type ccProperties struct {
+	Name                      *string
+	Owner                     *string
+	Defaults                  []string
+	Vendor_available          *bool
+	Generated_sources         []string
+	Generated_headers         []string
+	Group_static_libs         *bool
+	Shared_libs               []string
+	Static_libs               []string
+	Export_shared_lib_headers []string
+	Export_static_lib_headers []string
+	Export_generated_headers  []string
+}
+
+type javaProperties struct {
+	Name              *string
+	Owner             *string
+	Defaults          []string
+	No_framework_libs *bool
+	Sdk_version       *string
+	Srcs              []string
+	Libs              []string
+	Static_libs       []string
+}
diff --git a/build/utils.go b/build/utils.go
new file mode 100644
index 0000000..ba3ac8e
--- /dev/null
+++ b/build/utils.go
@@ -0,0 +1,43 @@
+// Copyright (C) 2017 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.
+
+package hidl
+
+// wrap(p, a, s) = [p + v + s for v in a]
+func wrap(prefix string, strs []string, suffix string) []string {
+	ret := make([]string, len(strs))
+	for i, v := range strs {
+		ret[i] = prefix + v + suffix
+	}
+	return ret
+}
+
+// concat(a...) = sum((i for i in a), [])
+func concat(sstrs ...[]string) []string {
+	var ret []string
+	for _, v := range sstrs {
+		ret = append(ret, v...)
+	}
+	return ret
+}
+
+func remove(str string, strs []string) []string {
+	var ret []string
+	for _, v := range strs {
+		if v != str {
+			ret = append(ret, v)
+		}
+	}
+	return ret
+}
diff --git a/c2hal/AST.cpp b/c2hal/AST.cpp
index e2ae13c..783a04e 100644
--- a/c2hal/AST.cpp
+++ b/c2hal/AST.cpp
@@ -29,7 +29,6 @@
 #include <string>
 #include <algorithm>
 #include <stdlib.h>
-#include <sys/dir.h>
 #include <sys/stat.h>
 
 namespace android {
@@ -317,7 +316,7 @@
 
     size_t start = 1;  // Ignore leading '/'
     size_t slashPos;
-    while ((slashPos = path.find("/", start)) != std::string::npos) {
+    while ((slashPos = path.find('/', start)) != std::string::npos) {
         std::string partial = path.substr(0, slashPos);
 
         struct stat st;
diff --git a/c2hal/Android.bp b/c2hal/Android.bp
index 03987f5..3dd9c6a 100644
--- a/c2hal/Android.bp
+++ b/c2hal/Android.bp
@@ -12,13 +12,9 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-subdirs = [
-    "test",
-]
-
 cc_binary_host {
     name: "c2hal",
-    cflags: hidl_flags,
+    defaults: ["hidl-gen-defaults"],
     srcs: [
         "AST.cpp",
         "c2hal_l.ll",
diff --git a/c2hal/Expression.cpp b/c2hal/Expression.cpp
index 7863b15..0ab864f 100644
--- a/c2hal/Expression.cpp
+++ b/c2hal/Expression.cpp
@@ -29,7 +29,7 @@
 static const std::regex RE_S64("[^ul](l|ll)$");
 static const std::regex RE_U64("[^ul](ul|ull)$");
 
-Expression::Type Expression::integralType(std::string integer) {
+Expression::Type Expression::integralType(const std::string& integer) {
     if (std::regex_search(integer, RE_S32)) {
         return Type::S32;
     }
@@ -55,8 +55,8 @@
     // because we are reducing everything to two ranks, we can heavily simplify
     // conversion rules
 
-#define SIGNED(i) (i & 2) // i & 0b10
-#define MAX_RANK(i) (i | 1) // i | 0b01
+#define SIGNED(i) ((i) & 2) // i & 0b10
+#define MAX_RANK(i) ((i) | 1) // i | 0b01
 
     if (lhs == rhs) {
         return lhs;
diff --git a/c2hal/Expression.h b/c2hal/Expression.h
index 9f04837..5449e55 100644
--- a/c2hal/Expression.h
+++ b/c2hal/Expression.h
@@ -63,7 +63,7 @@
         }
     }
 
-    static Type integralType(std::string integer);
+    static Type integralType(const std::string& integer);
     static Type coalesceTypes(Type lhs, Type rhs);
 
     static Expression *parenthesize(Expression *inner);
diff --git a/c2hal/c2hal_l.ll b/c2hal/c2hal_l.ll
index d5e4511..f613adc 100644
--- a/c2hal/c2hal_l.ll
+++ b/c2hal/c2hal_l.ll
@@ -50,8 +50,6 @@
 
 int check_type(yyscan_t yyscanner, struct yyguts_t *yyg);
 
-// TODO convert to parse params/lex params
-
 extern int start_token;
 
 extern std::string last_comment;
@@ -80,6 +78,7 @@
 #pragma clang diagnostic push
 #pragma clang diagnostic ignored "-Wunused-parameter"
 #pragma clang diagnostic ignored "-Wdeprecated-register"
+#pragma clang diagnostic ignored "-Wregister"
 
 %}
 
diff --git a/c2hal/test/simple.h b/c2hal/test/simple.h
index e3d7f3e..701ebe4 100644
--- a/c2hal/test/simple.h
+++ b/c2hal/test/simple.h
@@ -32,7 +32,7 @@
 
 /* Simple example */
 typedef struct simple_t {
-    /**
+    /*
      * Common methods of the simple device.
      */
     struct hw_device_t common;
@@ -67,7 +67,7 @@
 
 } simple_location_t;
 
-/** convenience API for coloring */
+/* convenience API for coloring */
 
 static inline int showColor(const struct hw_module_t* module,
         struct simple_t** device) {
diff --git a/c2hal/test/test.h b/c2hal/test/test.h
index b1a0058..3a83b0c 100644
--- a/c2hal/test/test.h
+++ b/c2hal/test/test.h
@@ -34,7 +34,6 @@
                  get rid of magic numbers */
 
 /* test */
-/** test */
 /* test **/
 /* test / ** ** / test */
 /* test //// ***** test /****/
@@ -91,7 +90,6 @@
 
 #undef ONE
 
-/*****************************************************************************/
 typedef void (*no_arg_fun)(void);
 
 typedef int (*other_fun)(int j);
@@ -110,7 +108,7 @@
 int (*global_fun_2)(struct framebuffer_device_t* dev, int enable);
 
 typedef struct framebuffer_device_t {
-    /**
+    /*
      * Common methods of the framebuffer device.
      */
     struct hw_device_t common;
@@ -324,7 +322,7 @@
     float c;
 } that_t;
 
-/**
+/*
  * return the frame size (number of bytes per sample) of an output stream.
  */
 static inline size_t audio_stream_out_frame_size(const struct audio_stream_out *s)
diff --git a/docs/Android.bp b/docs/Android.bp
new file mode 100644
index 0000000..2d7d78b
--- /dev/null
+++ b/docs/Android.bp
@@ -0,0 +1,64 @@
+// Copyright (C) 2007 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.
+
+//
+// hidl-doc
+//
+java_binary_host {
+    name: "hidl-doc",
+    manifest: "etc/manifest.txt",
+    srcs: [
+        "src/main.kt",
+        "src/writer/formatutils.kt",
+        "src/writer/elements/TypedefElement.kt",
+        "src/writer/elements/EnumElement.kt",
+        "src/writer/elements/AbstractElement.kt",
+        "src/writer/elements/CompoundElement.kt",
+        "src/writer/elements/MethodElement.kt",
+        "src/writer/files/AbstractFileWriter.kt",
+        "src/writer/files/InterfaceFileWriter.kt",
+        "src/writer/files/IndexFileWriter.kt",
+        "src/writer/files/TypesFileWriter.kt",
+        "src/writer/files/AbstractParserFileWriter.kt",
+        "src/writer/files/resources.kt",
+        "src/lexer/ILexer.kt",
+        "src/lexer/Token.kt",
+        "src/lexer/DocLexer.kt",
+        "src/lexer/HidlLexer.kt",
+        "src/parser/elements/EntryParser.kt",
+        "src/parser/elements/DocParser.kt",
+        "src/parser/elements/EntryCollectionParser.kt",
+        "src/parser/elements/AbstractParser.kt",
+        "src/parser/elements/DocAnnotationParser.kt",
+        "src/parser/elements/declarations/EnumDeclarationParser.kt",
+        "src/parser/elements/declarations/InterfaceDeclarationParser.kt",
+        "src/parser/elements/declarations/TypedefDeclarationParser.kt",
+        "src/parser/elements/declarations/MethodDeclarationParser.kt",
+        "src/parser/elements/declarations/AbstractDeclarationParser.kt",
+        "src/parser/elements/declarations/CompoundDeclarationParser.kt",
+        "src/parser/elements/AnnotationParser.kt",
+        "src/parser/utils.kt",
+        "src/parser/config.kt",
+        "src/parser/files/InterfaceFileParser.kt",
+        "src/parser/files/TypesFileParser.kt",
+        "src/parser/files/AbstractFileParser.kt",
+        "src/parser/files/package.kt",
+    ],
+    java_resources: [
+        "resources/template/index.html",
+        "resources/template/types.html",
+        "resources/template/interface.html",
+        "resources/assets/style.css",
+    ],
+}
diff --git a/docs/README.md b/docs/README.md
new file mode 100644
index 0000000..9624451
--- /dev/null
+++ b/docs/README.md
@@ -0,0 +1,35 @@
+# Install
+
+~~~
+$ m -j hidl-doc
+~~~
+
+# Usage
+
+View usage info:
+
+~~~
+$ ./bin/hidl-doc -h
+~~~
+
+Parse the audio `types.hal` file in the Android repo and output
+generated HTML reference to the reference directory. Enable verbose mode:
+
+~~~
+$ ./bin/hidl-doc -v -i /path/to/android/hardware/interfaces/audio/2.0/types.hal \
+  -o /path/to/output/en/reference/hidl/
+~~~
+
+Parse all HAL files in the Android `/hardware/interfaces/` directory
+and output generated HTML reference docs to reference directory. Skip files
+that encounter doc parse errors:
+
+~~~
+$ ./bin/hidl-doc -v -s -i /path/to/android/hardware/interfaces/ \
+  -o /path/to/output/en/reference/hidl/
+~~~
+# Templates
+
+HTML templates are used to generate the output docs and are in the
+`resources/template/` directory. Since these files are bundled up in the fat jar
+file, if you make any changes to the templates, `hidl-doc.jar` must be rebuilt.
diff --git a/docs/etc/manifest.txt b/docs/etc/manifest.txt
new file mode 100644
index 0000000..82888cf
--- /dev/null
+++ b/docs/etc/manifest.txt
@@ -0,0 +1 @@
+Main-Class: MainKt
\ No newline at end of file
diff --git a/docs/resources/assets/style.css b/docs/resources/assets/style.css
new file mode 100644
index 0000000..a9b8b16
--- /dev/null
+++ b/docs/resources/assets/style.css
@@ -0,0 +1,15 @@
+header #api-info-block {
+  float: right;
+  font-size: 0.9em;
+  color: #999;
+}
+
+header #api-info-block code {
+  font-size: 0.8em;
+  color: #37474f;
+}
+
+header code {
+  padding: 0;
+  background-color: transparent;
+}
\ No newline at end of file
diff --git a/docs/resources/template/index.html b/docs/resources/template/index.html
new file mode 100644
index 0000000..d4faee5
--- /dev/null
+++ b/docs/resources/template/index.html
@@ -0,0 +1,30 @@
+<!DOCTYPE html>
+<html devsite>
+<!--################    THIS FILE IS GENERATED     ################-->
+<!--################          DO NOT EDIT          ################-->
+<!--################  CHANGE THE HAL DOC COMMENTS  ################-->
+<head>
+  <title>$title | HIDL reference</title>
+  <meta name="project_path" value="/_project.yaml">
+  <meta name="book_path" value="/reference/hidl/_book.yaml">
+  <meta name="hide_page_heading" value="true">
+  <link href="/reference/hidl/assets/style.css" rel="stylesheet">
+</head>
+<body>
+  <header>
+    <h1 class="hide-from-toc">HIDL Reference</h1>
+    <p>
+      The HAL Interface Description Language (HIDL) specifies the interface
+      between a HAL and its users. It defines types and method calls, collected
+      into interfaces and packages. HIDL is a system for communicating between
+      codebases that may be compiled independently and is intended for
+      inter-process communication. See the
+      <a href="/devices/architecture/hidl">HIDL guides</a>.
+    </p>
+  </header>
+  <section>
+    <h2 class="hide-from-toc">Interfaces and types</h2>
+$entries
+  </section>
+</body>
+</html>
diff --git a/docs/resources/template/interface.html b/docs/resources/template/interface.html
new file mode 100644
index 0000000..feed37b
--- /dev/null
+++ b/docs/resources/template/interface.html
@@ -0,0 +1,18 @@
+<!DOCTYPE html>
+<html devsite>
+<!--################    THIS FILE IS GENERATED     ################-->
+<!--################          DO NOT EDIT          ################-->
+<!--################  CHANGE THE HAL DOC COMMENTS  ################-->
+<head>
+  <title>$name | HIDL reference</title>
+  <meta name="project_path" value="/_project.yaml">
+  <meta name="book_path" value="/reference/hidl/_book.yaml">
+  <meta name="hide_page_heading" value="true">
+  <link href="/reference/hidl/assets/style.css" rel="stylesheet">
+</head>
+<body>
+$header
+$propertyDefs
+$methodDefs
+</body>
+</html>
\ No newline at end of file
diff --git a/docs/resources/template/types.html b/docs/resources/template/types.html
new file mode 100644
index 0000000..d7d25a2
--- /dev/null
+++ b/docs/resources/template/types.html
@@ -0,0 +1,17 @@
+<!DOCTYPE html>
+<html devsite>
+<!--################    THIS FILE IS GENERATED     ################-->
+<!--################          DO NOT EDIT          ################-->
+<!--################  CHANGE THE HAL DOC COMMENTS  ################-->
+<head>
+  <title>$name | HIDL reference</title>
+  <meta name="project_path" value="/_project.yaml">
+  <meta name="book_path" value="/reference/hidl/_book.yaml">
+  <meta name="hide_page_heading" value="true">
+  <link href="/reference/hidl/assets/style.css" rel="stylesheet">
+</head>
+<body>
+$header
+$propertyDefs
+</body>
+</html>
\ No newline at end of file
diff --git a/docs/src/lexer/DocLexer.kt b/docs/src/lexer/DocLexer.kt
new file mode 100644
index 0000000..ec1a745
--- /dev/null
+++ b/docs/src/lexer/DocLexer.kt
@@ -0,0 +1,70 @@
+/*
+ * Copyright (C) 2017 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.
+ */
+
+package lexer
+
+import java.util.*
+
+object DocLexer : ILexer {
+
+    /**
+     * @param str The string should already be padded from the file lexer.
+     */
+    override fun tokenize(str: String): List<Token> {
+        val tokens = mutableListOf<Token>()
+        var token: String
+
+        //remove docblock comment indention - must go before others
+        val formattedStr = str.lines()
+                //remove docblock comment indent prefix (must go before others) ...
+                .map { it.replace(Regex("^\\s*\\*[^/]"), "") } //indented prefix except doc_end
+                .map { it.replace(Regex("^\\s*\\*$"), "") }    //prefix empty lines remain
+                //replace empty lines with something the scanner can pick out ...
+                .map { it.replace(Regex("$\\s*^"), TokenGrammar.EMPTY_LINE.value) }
+                .joinToString("\n")
+
+        Scanner(formattedStr).use { scanner ->
+            while (scanner.hasNext()) {
+                token = scanner.next()
+
+                when (token) {
+                    TokenGrammar.EMPTY_LINE.value -> tokens.add(TokenGrammar.newToken("", TokenGrammar.EMPTY_LINE))
+
+                    //if part of annotation, add following tag as well
+                    TokenGrammar.AT.value -> {
+                        tokens.add(TokenGrammar.newToken(token)) //'@'
+                        //determine if part of annotation
+                        for (annotation in TokenGrammar.docAnnotations()) {
+                            if (scanner.hasNext(annotation.value)) {
+                                tokens.add(TokenGrammar.newToken(scanner.next()))
+                            }
+                        }
+                    }
+
+                    //default to DocWord
+                    else -> {
+                        val id = TokenGrammar.getFromValueOrDefault(token)
+                        val category = if (id == TokenGrammar.WORD) TokenCategory.DocWord else id.category
+                        tokens.add(TokenGrammar.newToken(token, category))
+                        //TODO: Perhaps make all docblock words a DocWord
+                        //tokens.add(TokenGrammar.newToken(token, TokenCategory.DocWord))
+                    }
+                }
+            }
+        }
+        return tokens.toList()
+    }
+}
\ No newline at end of file
diff --git a/docs/src/lexer/HidlLexer.kt b/docs/src/lexer/HidlLexer.kt
new file mode 100644
index 0000000..1bc04fa
--- /dev/null
+++ b/docs/src/lexer/HidlLexer.kt
@@ -0,0 +1,107 @@
+/*
+ * Copyright (C) 2017 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.
+ */
+
+package lexer
+
+import java.text.ParseException
+import java.util.*
+
+object HidlLexer : ILexer {
+
+    /**
+     * Given the text of a HIDL file, return a list ot tokens.
+     * Scanner moves forward only, but can check queued tokens.
+     */
+    override fun tokenize(str: String): List<Token> {
+        val tokens = mutableListOf<Token>()
+        //match line to '*/', check for anything after on same line
+        val matchToDocEnd = Regex("""(.*)\s+${Regex.escape(TokenGrammar.DOC_END.value)}(.*)$""")
+
+        //pad delimiter tokens so the scanner picks them up.
+        val paddedStr = ILexer.padDelimiters(str)
+
+        Scanner(paddedStr).use { scanner ->
+            while (scanner.hasNext()) {
+                val token = scanner.next()
+
+                when (token) {
+                    //strip line comments
+                    TokenGrammar.COMMENT_LINE.value -> scanner.nextLine()
+
+                    //strip block comments -- jump to comment close
+                    TokenGrammar.COMMENT_START.value -> {
+                        if (scanner.findWithinHorizon(Regex.escape(TokenGrammar.DOC_END.value), 0) == null) {
+                            throw ParseException("Unable to find closing comment marker", tokens.lastIndex)
+                        }
+                    }
+
+                    //slurp text between /** and */ into a string,
+                    //tokenize string using the doc comment lexer,
+                    //append those tokens with the rest of the file tokens.
+                    TokenGrammar.DOC_START.value -> {
+                        tokens.add(TokenGrammar.newToken(token)) //doc_start
+                        //slurp everything until doc_end into a string. but want to keep newline formatting
+                        val sb = StringBuilder()
+                        while (scanner.hasNextLine()) {
+                            val line = scanner.nextLine()
+
+                            val matches = matchToDocEnd.find(line)?.groups
+                            if (matches != null) {
+                                if (!matches[2]!!.value.isNullOrBlank()) {
+                                    throw ParseException("No text after '*/' on same line: ${line}", 0)
+                                }
+                                //found doc_end
+                                sb.append(matches[1]!!.value)
+                                break
+                            } else {
+                                sb.appendln(line)
+                            }
+                        }
+                        //tokenize comment string and append all
+                        tokens += DocLexer.tokenize(sb.toString())
+                        tokens.add(TokenGrammar.newToken(TokenGrammar.DOC_END.value)) //doc_end
+                    }
+
+                    TokenGrammar.AT.value -> {
+                        tokens.add(TokenGrammar.newToken(token)) //'@'
+                        //determine if part of annotation tag
+                        for (annotation in TokenGrammar.annotations()) {
+                            if (scanner.hasNext(annotation.value)) {
+                                scanner.next() //annotation tag
+                                val annotationArgs = StringBuilder()
+                                //capture any args: (...)
+                                if (scanner.hasNext(Regex.escape(TokenGrammar.PAREN_OPEN.value))) {
+                                    while (!scanner.hasNext(Regex.escape(TokenGrammar.PAREN_CLOSE.value))) {
+                                        annotationArgs.append(scanner.next()).append(" ")
+                                    }
+                                    if (!scanner.hasNext()) {
+                                        throw ParseException("Unable to find closing annotation paren", tokens.lastIndex)
+                                    }
+                                    annotationArgs.append(scanner.next()) //')'
+                                }
+                                //all annotation args are embedded in the token's value
+                                tokens.add(TokenGrammar.newToken(identifier = annotation, value = annotationArgs.toString()))
+                            }
+                        }
+                    }
+
+                    else -> tokens.add(TokenGrammar.newToken(token))
+                }
+            }
+        }
+        return tokens.toList()
+    }
+}
\ No newline at end of file
diff --git a/docs/src/lexer/ILexer.kt b/docs/src/lexer/ILexer.kt
new file mode 100644
index 0000000..368ead7
--- /dev/null
+++ b/docs/src/lexer/ILexer.kt
@@ -0,0 +1,91 @@
+/*
+ * Copyright (C) 2017 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.
+ */
+
+package lexer
+
+import java.io.File
+
+interface ILexer {
+    fun tokenize(str: String): List<Token>
+
+    fun tokenize(file: File): List<Token> {
+        return this.tokenize(file.readText())
+    }
+
+    companion object {
+
+        fun padDelimiters(str: String): String {
+            val sb = StringBuilder()
+            val delimiters = TokenGrammar.values()
+                    .filter { it.category == TokenCategory.Delimiter }
+                    .filter { it != TokenGrammar.COMMENT_START } //don't convert '/**' to '/* *'
+                    .map { it.value } //return string representation
+
+            str.lineSequence().forEach { line ->
+                var newLine = line
+                for (token in delimiters) {
+                    newLine = newLine.replace(token, " $token ")
+                }
+                //delimiter corrections
+                newLine = unpadDecimal(newLine) //'nn . nn' => 'n.n'
+                newLine = newLine.replace(":\\s+:".toRegex(), TokenGrammar.PKG_SCOPE.value)  //': :' => '::'
+                //squeeze multi-char ops with chevrons
+                newLine = newLine.replace("<\\s+<".toRegex(), TokenGrammar.LSHIFT.value)
+                newLine = newLine.replace(">\\s+>".toRegex(), TokenGrammar.RSHIFT.value)
+                newLine = newLine.replace("<\\s+=".toRegex(), TokenGrammar.LEQ.value)
+                newLine = newLine.replace(">\\s+=".toRegex(), TokenGrammar.GEQ.value)
+
+                sb.appendln(newLine)
+            }
+            return sb.toString()
+        }
+
+        /**
+         * Replace 'nn . nn' with 'n.n'
+         * Doesn't take into account decimals with missing a prefix or suffix, e.g. '9.' or '.9'
+         */
+        private fun unpadDecimal(str: String): String {
+            var newStr = str
+            Regex("(\\d+)\\s*\\.\\s*(\\d+)").findAll(newStr).forEach { matchResult ->
+                val n1 = matchResult.groups[1]?.value
+                val n2 = matchResult.groups[2]?.value
+                if (n1 != null && n2 != null) {
+                    newStr = newStr.replace("${n1}\\s*\\.\\s*${n2}".toRegex(), "${n1}.${n2}")
+                }
+            }
+            return newStr
+        }
+
+        /**
+         * Clean up the padded and tokenized doc block (reverse padDelimiters)
+         */
+        fun unpadDelimiters(str: String): String {
+            var newStr = str
+            val delimiters = TokenGrammar.values()
+                    .filter { it.category == TokenCategory.Delimiter }
+                    .map { it.value } //return string representation
+
+            for (token in delimiters) {
+                newStr = newStr.replace(" $token ", token)
+            }
+            //special case
+            newStr = newStr.replace(Regex("\\s+\\.\\s*$"), ".") //end-of-line sentence periods
+            newStr = newStr.replace(",", ", ") //give comma some breathing room
+            return newStr
+        }
+
+    }
+}
\ No newline at end of file
diff --git a/docs/src/lexer/Token.kt b/docs/src/lexer/Token.kt
new file mode 100644
index 0000000..3038b77
--- /dev/null
+++ b/docs/src/lexer/Token.kt
@@ -0,0 +1,178 @@
+/*
+ * Copyright (C) 2017 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.
+ */
+
+package lexer
+
+data class Token(val identifier: TokenGrammar, val value: String, val category: TokenCategory)
+
+enum class TokenCategory {
+    Annotation, Delimiter, Keyword, Number, Op, TypeDef, Word, DocComment, DocAnnotation, DocWord
+}
+
+enum class TokenGrammar(val value: String, val category: TokenCategory) {
+
+    WORD("", TokenCategory.Word),
+    INTEGER("", TokenCategory.Number),
+    DECIMAL("", TokenCategory.Number),
+
+    AT("@", TokenCategory.Delimiter),
+    EMPTY_LINE("EMPTY_LINE", TokenCategory.Delimiter), //sub in doc string, don't include value in token
+
+    DOC_START("/**", TokenCategory.Delimiter),
+    DOC_END("*/", TokenCategory.Delimiter),
+    COMMENT_LINE("//", TokenCategory.Delimiter),
+    COMMENT_START("/*", TokenCategory.Delimiter),
+
+    // HIDL grammar: {android}/system/tools/hidl/hidl-gen_l.ll
+    ENUM("enum", TokenCategory.TypeDef),
+    EXTENDS("extends", TokenCategory.Keyword),
+    GENERATES("generates", TokenCategory.Keyword),
+    IMPORT("import", TokenCategory.Keyword),
+    INTERFACE("interface", TokenCategory.TypeDef),
+    PACKAGE("package", TokenCategory.Keyword),
+    STRUCT("struct", TokenCategory.TypeDef),
+    TYPEDEF("typedef", TokenCategory.TypeDef),
+    UNION("union", TokenCategory.TypeDef),
+    BITFIELD("bitfield", TokenCategory.TypeDef),
+    VEC("vec", TokenCategory.TypeDef),
+    REF("ref", TokenCategory.TypeDef),
+    ONEWAY("oneway", TokenCategory.Keyword),
+
+    BOOL("bool", TokenCategory.TypeDef),
+    INT8_T("int8_t", TokenCategory.TypeDef),
+    UINT8_T("uint8_t", TokenCategory.TypeDef),
+    INT16_T("int16_t", TokenCategory.TypeDef),
+    UINT16_T("uint16_t", TokenCategory.TypeDef),
+    INT32_T("int32_t", TokenCategory.TypeDef),
+    UINT32_T("uint32_t", TokenCategory.TypeDef),
+    INT64_T("int64_t", TokenCategory.TypeDef),
+    UINT64_T("int8_t", TokenCategory.TypeDef),
+    FLOAT("float", TokenCategory.TypeDef),
+    DOUBLE("double", TokenCategory.TypeDef),
+
+    DEATH_RECIPIENT("death_recipient", TokenCategory.TypeDef),
+    HANDLE("handle", TokenCategory.TypeDef),
+    MEMORY("memory", TokenCategory.TypeDef),
+    POINTER("pointer", TokenCategory.TypeDef),
+    STRING("string", TokenCategory.TypeDef),
+
+    FMQ_SYNC("fmq_sync", TokenCategory.TypeDef),
+    FMQ_UNSYNC("fmq_unsync", TokenCategory.TypeDef),
+
+    PAREN_OPEN("(", TokenCategory.Delimiter),
+    PAREN_CLOSE(")", TokenCategory.Delimiter),
+    CHEVRON_OPEN("<", TokenCategory.Delimiter),
+    CHEVRON_CLOSE(">", TokenCategory.Delimiter),
+    BRACE_OPEN("{", TokenCategory.Delimiter),
+    BRACE_CLOSE("}", TokenCategory.Delimiter),
+    BRACKET_OPEN("[", TokenCategory.Delimiter),
+    BRACKET_CLOSE("]", TokenCategory.Delimiter),
+    COLON(":", TokenCategory.Delimiter),
+    SEMICOLON(";", TokenCategory.Delimiter),
+    COMMA(",", TokenCategory.Delimiter),
+    PERIOD(".", TokenCategory.Delimiter),
+    EQUAL("=", TokenCategory.Op),
+    PLUS("+", TokenCategory.Op),
+    MINUS("-", TokenCategory.Op),
+    MULTIPLY("*", TokenCategory.Op),
+    DIVIDE("/", TokenCategory.Op),
+    MOD("%", TokenCategory.Op),
+    BITWISE_AND("&", TokenCategory.Op),
+    BITWISE_OR("|", TokenCategory.Op),
+    BITWISE_XOR("^", TokenCategory.Op),
+    LSHIFT("<<", TokenCategory.Op),
+    RSHIFT(">>", TokenCategory.Op),
+    LOGICAL_AND("&&", TokenCategory.Op),
+    LOGICAL_OR("||", TokenCategory.Op),
+    NEGATE("!", TokenCategory.Op),
+    COMPLEMENT("~", TokenCategory.Op),
+    LEQ("<=", TokenCategory.Op),
+    GEQ(">=", TokenCategory.Op),
+    EQUALITY("==", TokenCategory.Op),
+    NEQUALITY("!=", TokenCategory.Op),
+    QUESTION("?", TokenCategory.Op),
+
+    PKG_SCOPE("::", TokenCategory.Delimiter),
+
+    // vts tags
+    ENTRY("entry", TokenCategory.Annotation),
+    EXIT("exit", TokenCategory.Annotation),
+    CALLFLOW("callflow", TokenCategory.Annotation),
+    EXPORT("export", TokenCategory.Annotation),
+
+    // javadoc tags. Not all supported in HIDL
+    // http://docs.oracle.com/javase/1.5.0/docs/tooldocs/windows/javadoc.html#javadoctags
+    // https://docs.google.com/document/d/1zHzOtvI9vIADPmI211F_tXQUd-w6lP5u-Y98lvxPvYQ/view#heading=h.aopuaezi1is6
+    AUTHOR("author", TokenCategory.DocAnnotation),
+    CODE("code", TokenCategory.DocAnnotation),
+    DOC_ROOT("docRoot", TokenCategory.DocAnnotation),
+    DEPRECATED("deprecated", TokenCategory.DocAnnotation),
+    EXCEPTION("exception", TokenCategory.DocAnnotation),
+    INHERIT_DOC("inheritDoc", TokenCategory.DocAnnotation),
+    LINK("link", TokenCategory.DocAnnotation),
+    LINK_PLAIN("linkplain", TokenCategory.DocAnnotation),
+    LITERAL("literal", TokenCategory.DocAnnotation),
+    PARAM("param", TokenCategory.DocAnnotation),
+    RETURN("return", TokenCategory.DocAnnotation),
+    SEE("see", TokenCategory.DocAnnotation),
+    SERIAL("serial", TokenCategory.DocAnnotation),
+    SERIAL_DATA("serialData", TokenCategory.DocAnnotation),
+    SERIAL_FIELD("serialField", TokenCategory.DocAnnotation),
+    SINCE("since", TokenCategory.DocAnnotation),
+    THROWS("throws", TokenCategory.DocAnnotation),
+    VALUE("value", TokenCategory.DocAnnotation),
+    VERSION("version", TokenCategory.DocAnnotation);
+
+    companion object {
+        private val map = TokenGrammar.values().associateBy(TokenGrammar::value)
+        private val matchInt = Regex("\\d+")
+        private val matchFloat = Regex("\\d+[.]\\d+")
+
+        fun getFromValue(value: String): TokenGrammar? {
+            return map[value]
+        }
+
+        fun getFromValueOrDefault(value: String): TokenGrammar {
+            return getFromValue(value) ?: when {
+                matchInt.matches(value) -> INTEGER
+                matchFloat.matches(value) -> DECIMAL
+                else -> WORD
+            }
+        }
+
+        fun newToken(value: String): Token {
+            val tokenGrammar = getFromValueOrDefault(value)
+            return Token(tokenGrammar, value, tokenGrammar.category)
+        }
+
+        fun newToken(value: String, category: TokenCategory): Token {
+            val tokenGrammar = getFromValueOrDefault(value)
+            return Token(tokenGrammar, value, category)
+        }
+
+        fun newToken(value: String, identifier: TokenGrammar): Token {
+            return Token(identifier, value, identifier.category)
+        }
+
+        fun annotations(): List<TokenGrammar> {
+            return TokenGrammar.values().filter { it.category == TokenCategory.Annotation }
+        }
+
+        fun docAnnotations(): List<TokenGrammar> {
+            return TokenGrammar.values().filter { it.category == TokenCategory.DocAnnotation }
+        }
+    }
+}
\ No newline at end of file
diff --git a/docs/src/main.kt b/docs/src/main.kt
new file mode 100644
index 0000000..2069d2e
--- /dev/null
+++ b/docs/src/main.kt
@@ -0,0 +1,84 @@
+/*
+ * Copyright (C) 2017 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.
+ */
+
+import lexer.HidlLexer
+import lexer.Token
+import parser.LOG_NAME
+import parser.config
+import parser.files.AbstractFileParser
+import parser.files.InterfaceFileParser
+import parser.files.TypesFileParser
+import writer.files.*
+import java.nio.file.Paths
+import java.text.ParseException
+
+fun main(args: Array<String>) {
+    config.parseArgs(args)
+    if (config.verbose) println("$LOG_NAME args: ${config}")
+
+    val indexWriter = IndexFileWriter() //collects parser entries
+
+    /*
+     * parse and write HAL files
+     */
+    for (fp in config.files) {
+        println("$LOG_NAME Parsing input: $fp")
+
+        val tokens = HidlLexer.tokenize(fp)
+        val (parser, writer) = parseAndGetWriter(tokens)
+
+        indexWriter.addEntry(parser)
+
+        try {
+            //since lazily evaluated, check here for parse errors
+            if (writer.writeToFile()) println("$LOG_NAME Wrote file: ${writer.path}")
+
+        } catch (ex: ParseException) {
+            if (config.skipError) {
+                System.err.println("$LOG_NAME Error parsing file, skipping: $fp")
+                continue
+            } else {
+                System.err.println("$LOG_NAME Error parsing file: $fp")
+                throw ex
+            }
+        } finally {
+            if (config.verbose) writer.printInfo()
+        }
+    }
+
+    /*
+     * non-HAL file
+     */
+    if (indexWriter.writeToFile()) println("$LOG_NAME Wrote index: ${indexWriter.path}")
+
+    val cssPath = Paths.get("${config.outDir}/assets/style.css")
+    if (resources.copyToFile("/resources/assets/style.css", cssPath)) {
+        println("$LOG_NAME Copied resource file: $cssPath")
+    }
+}
+
+fun parseAndGetWriter(tokens: List<Token>): Pair<AbstractFileParser, AbstractParserFileWriter> {
+    val parser: AbstractFileParser
+    val writer: AbstractParserFileWriter
+    if (InterfaceFileParser.isInterface(tokens)) {
+        parser = InterfaceFileParser(tokens)
+        writer = InterfaceFileWriter(parser)
+    } else {
+        parser = TypesFileParser(tokens)
+        writer = TypesFileWriter(parser)
+    }
+    return Pair(parser, writer)
+}
\ No newline at end of file
diff --git a/docs/src/parser/config.kt b/docs/src/parser/config.kt
new file mode 100644
index 0000000..125b4ac
--- /dev/null
+++ b/docs/src/parser/config.kt
@@ -0,0 +1,156 @@
+/*
+ * Copyright (C) 2017 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.
+ */
+
+package parser
+
+import java.io.File
+import java.nio.file.Files
+import java.nio.file.Path
+import java.nio.file.Paths
+import kotlin.system.exitProcess
+
+const val LOG_NAME = "[hidl-doc]"
+
+fun printUsage() {
+    println("""
+Usage: hidl-doc [-i path]
+ -i=path  Add input HAL file or directory to parse
+ -o=dir   Output directory of generated HTML [${config.outDir}]
+ -x=path  Exclude file or directory from files to parse
+ -v       Verbose mode, print parsing info
+ -h       Print this help and exit
+ Error modes:
+ -w       Warn on errors instead of exiting
+ -l       Lint. Warn-only and do not generate files
+ -e       Error and exit on warnings
+ -s       Skip files that encounter parse errors
+""".trim())
+}
+
+object config {
+    val files = mutableListOf<File>()
+    var outDir = toPath("~/out/hidl-doc/html")
+    var verbose = false
+    var lintMode = false
+    var warnOnly = false
+    var errorOnly = false
+    var skipError = false
+
+    override fun toString(): String {
+        return """
+verbose: $verbose
+warnOnly: $warnOnly
+errorOnly: $errorOnly
+skipError: $skipError
+outDir: $outDir
+files: $files
+"""
+    }
+
+    private const val HAL_EXTENSION = ".hal"
+
+    fun parseArgs(args: Array<String>) {
+        if (args.isEmpty()) {
+            printUsage()
+            exitProcess(1)
+        }
+
+        val dirPathArgs = mutableListOf<Path>()
+        val filePathArgs = mutableListOf<Path>()
+        val excludedPathArgs = mutableListOf<Path>()
+
+        val iter = args.iterator()
+        var arg: String
+
+        //parse command-line arguments
+        while (iter.hasNext()) {
+            arg = iter.next()
+
+            when (arg) {
+                "-i" -> {
+                    val path = toPath(iter.next())
+                    if (Files.isDirectory(path)) dirPathArgs.add(path) else filePathArgs.add(path)
+                }
+                "-x" -> excludedPathArgs.add(toPath(iter.next()).toAbsolutePath())
+                "-o" -> outDir = toPath(iter.next())
+                "-v" -> verbose = true
+                "-l" -> { lintMode = true; warnOnly = true }
+                "-w" -> warnOnly = true
+                "-e" -> errorOnly = true
+                "-s" -> skipError = true
+                "-h" -> {
+                    printUsage()
+                    exitProcess(0)
+                }
+                else -> {
+                    System.err.println("Unknown option: $arg")
+                    printUsage()
+                    exitProcess(1)
+                }
+            }
+        }
+
+        //collect files (explicitly passed and search directories)
+        val allFiles = mutableListOf<File>()
+
+        //add individual files
+        filePathArgs.filterNot { excludedPathArgs.contains(it.toAbsolutePath()) }
+                .map { it.toFile() }.map { fp ->
+            if (!fp.isFile || !fp.canRead() || !fp.absolutePath.toLowerCase().endsWith(HAL_EXTENSION)) {
+                System.err.println("Error: Invalid $HAL_EXTENSION file: ${fp.path}")
+                exitProcess(1)
+            }
+            fp
+        }.map { allFiles.add(it) }
+
+        //check directory args
+        dirPathArgs.map { it.toFile() }
+                .map { findFiles(it, allFiles, HAL_EXTENSION, excludedPathArgs) }
+
+        //consolidate duplicates
+        allFiles.distinctBy { it.canonicalPath }
+                .forEach { files.add(it) }
+
+        if (files.isEmpty()) {
+            System.err.println("Error: Can't find any $HAL_EXTENSION files")
+            exitProcess(1)
+        }
+    }
+
+    /**
+     * Recursively search for files in a directory matching an extension and add to files.
+     */
+    private fun findFiles(dir: File, files: MutableList<File>, ext: String, excludedPaths: List<Path>) {
+        if (!dir.isDirectory || !dir.canRead()) {
+            System.err.println("Invalid directory: ${dir.path}, aborting")
+            exitProcess(1)
+        }
+        dir.listFiles()
+                .filterNot { excludedPaths.contains(it.toPath().toAbsolutePath()) }
+                .forEach { fp ->
+                    if (fp.isDirectory) {
+                        findFiles(fp, files, ext, excludedPaths)
+                    } else if (fp.absolutePath.toLowerCase().endsWith(ext)) {
+                        files.add(fp)
+                    }
+                }
+    }
+
+    private fun toPath(string: String): Path {
+        //replace shell expansion for HOME
+        return Paths.get(string.replaceFirst("~", System.getProperty("user.home")))
+    }
+}
\ No newline at end of file
diff --git a/docs/src/parser/elements/AbstractParser.kt b/docs/src/parser/elements/AbstractParser.kt
new file mode 100644
index 0000000..45c1fc2
--- /dev/null
+++ b/docs/src/parser/elements/AbstractParser.kt
@@ -0,0 +1,121 @@
+/*
+ * Copyright (C) 2017 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.
+ */
+
+package parser.elements
+
+import lexer.Token
+import lexer.TokenGrammar
+import parser.peekPreviousToken
+import parser.peekToken
+import java.text.ParseException
+
+/**
+ * Start parsing at position in an iterator. Find the end, collect the results.
+ * @param iter An iterator of a list of tokens, starting at a position to parse.
+ */
+abstract class AbstractParser(iter: ListIterator<Token>) {
+
+    val indexStart: Int
+
+    init {
+        while (iter.hasNext() && peekToken(iter)?.identifier == TokenGrammar.EMPTY_LINE) {
+            iter.next() //skip over beginning empty lines
+        }
+        require(iter.hasNext()) { "Iterator is empty" }
+        indexStart = iter.nextIndex()
+    }
+
+    /**
+     * Do something with the tokens.
+     */
+    abstract fun parseTokens(tokens: List<Token>)
+
+    /**
+     * Determine end of token sequence, collect tokens from here to there.
+     */
+    abstract fun scanTokens(iter: ListIterator<Token>): List<Token>
+
+    protected fun scanDocTokens(iter: ListIterator<Token>): List<Token> {
+        val tokens = mutableListOf<Token>()
+        var token: Token
+
+        //ignore any empty lines that start the doc block (if called after doc_start)
+        while (peekPreviousToken(iter)?.identifier == TokenGrammar.EMPTY_LINE) iter.previous()
+
+        //queue up doc_start if called after
+        if (peekPreviousToken(iter)?.identifier == TokenGrammar.DOC_START) iter.previous()
+
+        if (peekToken(iter)!!.identifier != TokenGrammar.DOC_START)
+            throw ParseException("Doc comment blocks must begin with ${TokenGrammar.DOC_START.value}", this.indexStart)
+
+        tokens.add(iter.next()) //doc_start
+
+        while (iter.hasNext()) {
+            token = iter.next()
+            tokens.add(token)
+            if (token.identifier == TokenGrammar.DOC_END) {
+                break
+            } else if (token.identifier == TokenGrammar.DOC_START) {
+                throw ParseException("Nested doc comments not allowed", this.indexStart)
+            }
+        }
+
+        if (peekPreviousToken(iter)?.identifier != TokenGrammar.DOC_END) {
+            throw ParseException("Unable to find doc comment end", this.indexStart)
+        }
+        return tokens
+    }
+
+    /**
+     * Collect annotations (optional) to end of declaration (code body), may be nested.
+     */
+    protected fun scanDeclarationTokens(iter: ListIterator<Token>): List<Token> {
+        val tokens = mutableListOf<Token>()
+        var token: Token
+        var nestLevel = 0
+        var inDoc = false
+
+        while (iter.hasNext()) {
+            token = iter.next()
+            tokens.add(token)
+
+            if (token.identifier == TokenGrammar.DOC_START) {
+                inDoc = true
+            } else if (token.identifier == TokenGrammar.DOC_END) {
+                inDoc = false
+            }
+
+            if (inDoc) {
+                continue
+            } else if (token.identifier == TokenGrammar.BRACE_OPEN) {
+                nestLevel++
+            } else if (token.identifier == TokenGrammar.BRACE_CLOSE) {
+                nestLevel--
+            } else if (token.identifier == TokenGrammar.SEMICOLON && nestLevel == 0) {
+                break
+            }
+        }
+        assert(tokens.last().identifier == TokenGrammar.SEMICOLON)
+        return tokens
+    }
+
+    fun resetIterator(iter: ListIterator<Token>) {
+        while (iter.hasPrevious() && iter.previousIndex() >= indexStart) {
+            iter.previous()
+        }
+        assert(iter.nextIndex() == this.indexStart)
+    }
+}
\ No newline at end of file
diff --git a/docs/src/parser/elements/AnnotationParser.kt b/docs/src/parser/elements/AnnotationParser.kt
new file mode 100644
index 0000000..a1a32b4
--- /dev/null
+++ b/docs/src/parser/elements/AnnotationParser.kt
@@ -0,0 +1,67 @@
+/*
+ * Copyright (C) 2017 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.
+ */
+
+package parser.elements
+
+import lexer.Token
+import lexer.TokenCategory
+import lexer.TokenGrammar
+import parser.peekPreviousToken
+import parser.peekToken
+import java.text.ParseException
+
+class AnnotationParser(iter: ListIterator<Token>, var shouldResetIterator: Boolean = false) : AbstractParser(iter) {
+
+    lateinit var name: TokenGrammar
+    lateinit var value: String
+
+    init {
+        parseTokens(scanTokens(iter))
+        if (shouldResetIterator) resetIterator(iter)
+    }
+
+    override fun scanTokens(iter: ListIterator<Token>): List<Token> {
+        val tokens = mutableListOf<Token>()
+        //depending how called, queue up annotation
+        if (peekToken(iter)?.identifier == TokenGrammar.AT) iter.next()
+        if (peekPreviousToken(iter)?.category == TokenCategory.Annotation) iter.previous()
+
+        if (peekToken(iter)!!.category != TokenCategory.Annotation)
+            throw ParseException("Doc token sequence must begin with an annotation", this.indexStart)
+
+        //just one token, info embedded
+        tokens.add(iter.next())
+        return tokens
+    }
+
+    override fun parseTokens(tokens: List<Token>) {
+        val iter = tokens.listIterator()
+        assert(peekToken(iter)!!.category == TokenCategory.Annotation)
+        var token = iter.next()
+
+        this.name = token.identifier
+        this.value = parseAnnotationValue(token)
+    }
+
+    //capture text between parens
+    private fun parseAnnotationValue(token: Token): String {
+        return Regex(""".*\((.*)\).*""")
+                .matchEntire(token.value)
+                ?.groups?.get(1)
+                ?.value?.trim()
+                ?: ""
+    }
+}
\ No newline at end of file
diff --git a/docs/src/parser/elements/DocAnnotationParser.kt b/docs/src/parser/elements/DocAnnotationParser.kt
new file mode 100644
index 0000000..ee043da
--- /dev/null
+++ b/docs/src/parser/elements/DocAnnotationParser.kt
@@ -0,0 +1,119 @@
+/*
+ * Copyright (C) 2017 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.
+ */
+
+package parser.elements
+
+import lexer.ILexer
+import lexer.Token
+import lexer.TokenCategory
+import lexer.TokenGrammar
+import parser.peekPreviousToken
+import parser.peekToken
+import java.text.ParseException
+
+
+class DocAnnotationParser(iter: ListIterator<Token>, var shouldResetIterator: Boolean = false) : AbstractParser(iter) {
+
+    lateinit var tag: TokenGrammar
+    var arg: String? = null //some tags have arguments (eg. @param arg desc)
+    lateinit var description: String
+
+    init {
+        parseTokens(scanTokens(iter))
+        if (shouldResetIterator) resetIterator(iter)
+    }
+
+    private fun formatValue(tokens: List<Token>): String {
+        return if (tokens.isEmpty()) {
+            ""
+        } else {
+            tokens.map {
+                when (it.identifier) {
+                    TokenGrammar.EMPTY_LINE -> "\n\n"
+                    else -> it.value
+                }
+            }
+                    .joinToString(" ")
+                    .let { ILexer.unpadDelimiters(it) }
+        }
+    }
+
+    /**
+     * Scan until: doc end token, empty line, another @param
+     */
+    override fun scanTokens(iter: ListIterator<Token>): List<Token> {
+        val tokens = mutableListOf<Token>()
+        var token: Token
+
+        //depending how invoked, queue up doc annotation token
+        if (peekToken(iter)?.identifier == TokenGrammar.AT) iter.next()
+        if (peekPreviousToken(iter)?.category == TokenCategory.DocAnnotation) iter.previous()
+
+        if (peekToken(iter)!!.category != TokenCategory.DocAnnotation)
+            throw ParseException("Token sequence must begin with a DocAnnotation", this.indexStart)
+
+        loop@ while (iter.hasNext()) {
+            token = iter.next()
+
+            when {
+                //descriptions don't span blank lines
+                token.identifier == TokenGrammar.EMPTY_LINE -> break@loop
+
+                //if doc block ends or found next annotation tag, back up and bail
+                token.identifier == TokenGrammar.DOC_END ||
+                token.identifier == TokenGrammar.AT && peekToken(iter)?.category == TokenCategory.DocAnnotation -> {
+                    iter.previous()
+                    break@loop
+                }
+
+                else -> tokens.add(token)
+            }
+        }
+        return tokens
+    }
+
+    override fun parseTokens(tokens: List<Token>) {
+        val iter = tokens.listIterator()
+        assert(iter.hasNext())
+        val token = iter.next()
+
+        if (token.category != TokenCategory.DocAnnotation)
+            throw ParseException("Invalid doc anootation tag: ${token.value}", this.indexStart)
+
+        //annotation tag name (must be in TokenGrammar)
+        this.tag = token.identifier
+
+        //annotation tag can take an optional argument
+        //so can return (preferred). TODO: check HALs if mandatory
+        if (token.identifier == TokenGrammar.PARAM || token.identifier == TokenGrammar.RETURN) {
+            if (iter.hasNext()) this.arg = iter.next().value
+        }
+
+        //the rest is annotation description
+        val descTokens = mutableListOf<Token>()
+        while (iter.hasNext()) {
+            descTokens.add(iter.next())
+        }
+
+        this.description = if (descTokens.isEmpty()) {
+            ""
+        } else {
+            descTokens.map { if (it.identifier == TokenGrammar.EMPTY_LINE) "\n\n" else it.value }
+                    .joinToString(" ")
+                    .let { ILexer.unpadDelimiters(it) }
+        }
+    }
+}
\ No newline at end of file
diff --git a/docs/src/parser/elements/DocParser.kt b/docs/src/parser/elements/DocParser.kt
new file mode 100644
index 0000000..fd1f8a1
--- /dev/null
+++ b/docs/src/parser/elements/DocParser.kt
@@ -0,0 +1,75 @@
+/*
+ * Copyright (C) 2017 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.
+ */
+
+package parser.elements
+
+import lexer.ILexer
+import lexer.Token
+import lexer.TokenCategory
+import lexer.TokenGrammar
+import parser.peekToken
+
+class DocParser(iter: ListIterator<Token>, var shouldResetIterator: Boolean = false) : AbstractParser(iter) {
+
+    val description: String by lazy { formatDescription(this.descTokens) }
+    var docAnnotationParsers = mutableListOf<DocAnnotationParser>()
+
+    private var descTokens = mutableListOf<Token>()
+
+    init {
+        parseTokens(scanTokens(iter))
+        if (shouldResetIterator) resetIterator(iter)
+    }
+
+    private fun formatDescription(tokens: List<Token>): String {
+        return tokens
+                .filterNot { it.identifier == TokenGrammar.DOC_START }
+                .filterNot { it.identifier == TokenGrammar.DOC_END }
+                .map {
+                    when (it.identifier) {
+                        TokenGrammar.EMPTY_LINE -> "\n\n"
+                        else -> it.value
+                    }
+                }
+                .joinToString(" ")
+                .let { ILexer.unpadDelimiters(it) }
+    }
+
+    override fun scanTokens(iter: ListIterator<Token>): List<Token> {
+        //keep doc_start and doc_end tokens /** ... */
+        return scanDocTokens(iter)
+    }
+
+    override fun parseTokens(tokens: List<Token>) {
+        val iter = tokens.listIterator()
+        var token = iter.next() //doc_start
+
+        assert(token.identifier == TokenGrammar.DOC_START)
+        assert(tokens.last().identifier == TokenGrammar.DOC_END)
+
+        loop@ while(iter.hasNext()) {
+            token = iter.next()
+
+            when {
+                token.identifier == TokenGrammar.AT && peekToken(iter)?.category == TokenCategory.DocAnnotation -> {
+                    docAnnotationParsers.add(DocAnnotationParser(iter))  //increments iterator
+                }
+                token.identifier == TokenGrammar.DOC_END -> break@loop
+                else -> this.descTokens.add(token)
+            }
+        }
+    }
+}
\ No newline at end of file
diff --git a/docs/src/parser/elements/EntryCollectionParser.kt b/docs/src/parser/elements/EntryCollectionParser.kt
new file mode 100644
index 0000000..493998c
--- /dev/null
+++ b/docs/src/parser/elements/EntryCollectionParser.kt
@@ -0,0 +1,72 @@
+/*
+ * Copyright (C) 2017 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.
+ */
+
+package parser.elements
+
+import lexer.Token
+import lexer.TokenGrammar
+import parser.config
+import writer.warn
+import java.text.ParseException
+
+/**
+ * Collection of doc entryParsers in a token stream.
+ * Typically, like entries are grouped together in a file (eg. Interface def),
+ * But could be useful for declarations with fields (enums, structs).
+ */
+class EntryCollectionParser(iter: ListIterator<Token>, var shouldResetIterator: Boolean = false) : AbstractParser(iter) {
+
+    var entryParsers = mutableListOf<EntryParser>()
+
+    constructor(tokens: List<Token>) : this(tokens.listIterator())
+
+    init {
+        parseTokens(scanTokens(iter))
+        if (shouldResetIterator) this.resetIterator(iter)
+    }
+
+    //use all the tokens
+    override fun scanTokens(iter: ListIterator<Token>): List<Token> {
+        val tokens = mutableListOf<Token>()
+        while (iter.hasNext()) {
+            tokens.add(iter.next())
+        }
+        return tokens
+    }
+
+    override fun parseTokens(tokens: List<Token>) {
+        val iter = tokens.listIterator()
+        var token: Token
+
+        //find entry parsers - must start with doc_start
+        while(iter.hasNext()) {
+            token = iter.next()
+
+            if (token.identifier == TokenGrammar.DOC_START) {
+                try {
+                    entryParsers.add(EntryParser(iter)) //advances iterator past declaration
+                } catch (ex: IllegalEntryException) {
+                    if (config.warnOnly) {
+                        //bail on current entry but continue
+                        warn("${ex.message}, skipping entry")
+                    } else {
+                        throw ParseException(ex.message, this.indexStart)
+                    }
+                }
+            }
+        }
+    }
+}
\ No newline at end of file
diff --git a/docs/src/parser/elements/EntryParser.kt b/docs/src/parser/elements/EntryParser.kt
new file mode 100644
index 0000000..30ffc3b
--- /dev/null
+++ b/docs/src/parser/elements/EntryParser.kt
@@ -0,0 +1,162 @@
+/*
+ * Copyright (C) 2017 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.
+ */
+
+package parser.elements
+
+import lexer.Token
+import lexer.TokenCategory
+import lexer.TokenGrammar
+import parser.config
+import parser.elements.declarations.*
+import parser.peekPreviousToken
+import parser.peekToken
+import writer.tokenValues
+import writer.warn
+import java.text.ParseException
+
+//an entry consists of: doc block, annotationParsers, declarationParser (code sig)
+//EntryParser contains:
+//- docParser
+//  * description
+//  * docAnnotationParsers
+//    - tag (token)
+//    - arg?
+//    - description
+//- annotationParsers
+//  * name
+//  * value
+//- declarationParser
+//  * name
+//  * members [CompoundDeclarationParser]: type, name, tokens, typedef [CompoundMemberDeclaration]
+//  * members [EnumDeclarationParser]: name, value?
+//  * type [EnumDeclarationParser]
+//  * type [TypedefDeclarationParser]
+//  * extendsName [InterfaceDeclarationParser]
+//  * extendsVersion [InterfaceDeclarationParser]
+//  * prefix [MethodDeclarationParser]
+//  * params [MethodDeclarationParser]: ArgEntry: type, name
+//  * returns [[MethodDeclarationParser]: ArgEntry: type, name
+
+class IllegalEntryException(msg: String? = null, cause: Throwable? = null) : Exception(msg, cause)
+
+/**
+ * An entry inclused the doc comment block, code docAnnotationParsers, and method signature/interface
+ */
+class EntryParser(iter: ListIterator<Token>, var shouldResetIterator: Boolean = false) : AbstractParser(iter) {
+
+    //doc description, summary, and doc annottions
+    lateinit var docParser: DocParser
+    //annotation
+    val annotationParsers = mutableListOf<AnnotationParser>()
+    //declaration - properties depend on declarationParser subclass
+    lateinit var declarationParser: AbstractDeclarationParser
+
+    init {
+        parseTokens(scanTokens(iter))
+        if (shouldResetIterator) resetIterator(iter)
+    }
+
+    //start at doc_start, collect until end of declaration
+    override fun scanTokens(iter: ListIterator<Token>): List<Token> {
+        //queue up doc_start
+        //ignore any empty lines that start the doc block
+        while (peekPreviousToken(iter)?.identifier == TokenGrammar.EMPTY_LINE) iter.previous()
+        //if called after the doc_start was found
+        if (peekPreviousToken(iter)?.identifier == TokenGrammar.DOC_START) iter.previous()
+
+        val tokens = mutableListOf<Token>()
+        //collect doc block /** ... */
+        tokens += scanDocTokens(iter)
+        //collect annotations and declaration, nested to semicolon
+        tokens += scanDeclarationTokens(iter)
+        return tokens
+    }
+
+    override fun parseTokens(tokens: List<Token>) {
+        val iter = tokens.listIterator()
+
+        /*
+         * doc comment block
+         */
+        do {
+            assert(peekToken(iter)!!.identifier == TokenGrammar.DOC_START)
+            this.docParser = DocParser(iter) //increments iterator
+            assert(peekPreviousToken(iter)!!.identifier == TokenGrammar.DOC_END)
+
+            //if there's consecutive doc blocks, use the last one found in warning mode, otherwise error
+            if (peekToken(iter)?.identifier != TokenGrammar.DOC_START) {
+                break //good to go
+            } else {
+                val msg = "Found consecutive doc block after: ${this.docParser.description}"
+                if (config.warnOnly) {
+                    warn("${msg}\nUsing last found doc block.")
+                } else {
+                    throw ParseException(msg, this.indexStart)
+                }
+            }
+        } while (true)
+
+        /*
+         * annotations (optional)
+         */
+        while (iter.hasNext() && peekToken(iter)!!.identifier == TokenGrammar.AT) {
+            iter.next()
+            if (peekToken(iter)?.category == TokenCategory.Annotation) {
+                this.annotationParsers.add(AnnotationParser(iter)) //increments iterator
+            } else {
+                throw ParseException("Unknown annotation tag: ${peekToken(iter)?.value}", this.indexStart)
+            }
+        }
+
+        /*
+         * declaration
+         */
+        val token = peekToken(iter) ?: throw ParseException("No declaration body available", this.indexStart)
+
+        //check we're not at an annotation
+        assert(token.identifier != TokenGrammar.AT && token.category != TokenCategory.Annotation)
+
+        /*
+         * known bad starts for a declaration
+         */
+
+        if (token.identifier == TokenGrammar.DOC_START) {
+            throw ParseException("Bad doc block location:\n${tokenValues(tokens)}", this.indexStart)
+        } else if (token.identifier == TokenGrammar.PACKAGE) {
+            //usually this means they've used a doc block for the license
+            throw IllegalEntryException("Don't document the package declaration") //handled in EntryCollectionParser
+        } else if (token.category != TokenCategory.Word
+                && token.category != TokenCategory.TypeDef
+                && token.category != TokenCategory.Keyword) {
+            //sanity check - skip entry or bail
+            throw IllegalEntryException("Invalid start for entry declaration: '${token.value}'\n" +
+                    "tokens: ${tokenValues(tokens)}")
+            //throw ParseException("Invalid start for entry declaration: ${token}\ntoken: ${token.value}\n${tokenValues(tokens)}", this.indexStart)
+        }
+
+        this.declarationParser = when (token.identifier) {
+            TokenGrammar.INTERFACE -> {
+                this.shouldResetIterator = true
+                InterfaceDeclarationParser(iter)
+            }
+            TokenGrammar.ENUM -> EnumDeclarationParser(iter)
+            TokenGrammar.TYPEDEF -> TypedefDeclarationParser(iter)
+            TokenGrammar.STRUCT, TokenGrammar.UNION -> CompoundDeclarationParser(iter)
+            else -> MethodDeclarationParser(iter)
+        }
+
+    }
+}
\ No newline at end of file
diff --git a/docs/src/parser/elements/declarations/AbstractDeclarationParser.kt b/docs/src/parser/elements/declarations/AbstractDeclarationParser.kt
new file mode 100644
index 0000000..6d906a5
--- /dev/null
+++ b/docs/src/parser/elements/declarations/AbstractDeclarationParser.kt
@@ -0,0 +1,114 @@
+/*
+ * Copyright (C) 2017 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.
+ */
+
+package parser.elements.declarations
+
+import lexer.Token
+import lexer.TokenCategory
+import lexer.TokenGrammar
+import parser.elements.AbstractParser
+import parser.peekPreviousToken
+import parser.peekToken
+import java.text.ParseException
+
+//can be a method, struct, enum, typedef
+abstract class AbstractDeclarationParser(iter: ListIterator<Token>) : AbstractParser(iter) {
+
+    abstract var name: String //user-specified name declarationParser
+
+    //should be segmented in EntryParser, remaining tokens are the declarationParser, may be nested
+    override fun scanTokens(iter: ListIterator<Token>): List<Token> {
+        val token = peekPreviousToken(iter) ?: throw ParseException("No token before declaration", this.indexStart)
+
+        if (token.category != TokenCategory.Annotation && token.identifier != TokenGrammar.DOC_END)
+            throw ParseException("Invalid declaration start", this.indexStart)
+
+        return scanDeclarationTokens(iter)
+    }
+
+    /**
+     * Takes a delimited separated list and splits entries into list of list<token>.
+     * Ignore nested lists using same open/close delimiter.
+     * For method param lists, enum members, struct members, etc.
+     */
+    protected fun scanDelimitedList(iter: ListIterator<Token>,
+                                    delimiter: TokenGrammar = TokenGrammar.COMMA,
+                                    openDelimiter: TokenGrammar = TokenGrammar.PAREN_OPEN,
+                                    closeDelimiter: TokenGrammar = TokenGrammar.PAREN_CLOSE): List<List<Token>> {
+        val allFields = mutableListOf<List<Token>>() //top-level list
+        //queue up list open
+        if (iter.hasPrevious() && peekPreviousToken(iter)!!.identifier == openDelimiter) {
+            iter.previous()
+        }
+        var token = iter.next()
+        if (token.identifier != openDelimiter)
+            throw ParseException("Expected list start '${openDelimiter}', but got '${token.identifier}'", this.indexStart)
+
+        // collect tokens between open/close delimiters, fields separated by delimiter.
+        // ignore if nested, ignore in doc comment
+        while (iter.hasNext()) {
+            token = peekToken(iter)!! //iter.next()
+
+            if (token.identifier == closeDelimiter) {
+                iter.next()
+                break
+            } else if (token.identifier == delimiter) {
+                iter.next()
+                continue //skip
+            } else {
+                //start field entry
+                val fieldTokens = mutableListOf<Token>()
+                var inDoc = false
+                var nestLevel = 0
+
+                while (iter.hasNext()) {
+                    token = iter.next()
+
+                    if (token.identifier == TokenGrammar.DOC_START) {
+                        inDoc = true
+                    } else if (token.identifier == TokenGrammar.DOC_END) {
+                        inDoc = false
+                    }
+
+                    //check for end of field
+                    if ((token.identifier == delimiter || token.identifier == closeDelimiter) && nestLevel == 0 && !inDoc) {
+                        break
+                    } else {
+                        fieldTokens.add(token)
+                    }
+
+                    if (token.identifier == openDelimiter) {
+                        nestLevel++
+                    } else if (token.identifier == closeDelimiter && nestLevel > 0) {
+                        nestLevel--
+                    }
+                }
+
+                //add entry
+                allFields.add(fieldTokens)
+                //check for end of list
+                if (token.identifier == closeDelimiter && nestLevel == 0) {
+                    break
+                }
+            }
+        }
+
+        if (!iter.hasPrevious() || peekPreviousToken(iter)!!.identifier != closeDelimiter) {
+            throw ParseException("Didn't find closing '${closeDelimiter.value}' for list, found '${peekPreviousToken(iter)!!.value}'", this.indexStart)
+        }
+        return allFields
+    }
+}
\ No newline at end of file
diff --git a/docs/src/parser/elements/declarations/CompoundDeclarationParser.kt b/docs/src/parser/elements/declarations/CompoundDeclarationParser.kt
new file mode 100644
index 0000000..69f82d1
--- /dev/null
+++ b/docs/src/parser/elements/declarations/CompoundDeclarationParser.kt
@@ -0,0 +1,126 @@
+/*
+ * Copyright (C) 2017 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.
+ */
+
+package parser.elements.declarations
+
+import lexer.Token
+import lexer.TokenCategory
+import lexer.TokenGrammar
+import parser.elements.DocParser
+import writer.tokenValues
+import java.text.ParseException
+
+/**
+ * Used for Structs and Unions
+ */
+class CompoundDeclarationParser(iter: ListIterator<Token>, var shouldResetIterator: Boolean = false) : AbstractDeclarationParser(iter) {
+    lateinit var type: TokenGrammar
+    lateinit override var name: String
+    var members = mutableListOf<IMemberDeclaration>() //defined below
+
+    init {
+        parseTokens(scanTokens(iter))
+        if (shouldResetIterator) resetIterator(iter)
+    }
+
+    override fun parseTokens(tokens: List<Token>) {
+        val iter = tokens.listIterator()
+        var token = iter.next()
+        assert(token.identifier == TokenGrammar.STRUCT || token.identifier == TokenGrammar.UNION)
+        assert(tokens.last().identifier == TokenGrammar.SEMICOLON)
+
+        //type - struct or union
+        this.type = token.identifier
+
+        //name
+        token = iter.next()
+        if (token.category != TokenCategory.Word)
+            throw ParseException("Invalid struct name: ${tokenValues(tokens)}", this.indexStart)
+        this.name = token.value
+
+        //parse each semicolon-delimited statement
+        scanDelimitedList(iter,
+                delimiter = TokenGrammar.SEMICOLON,
+                openDelimiter = TokenGrammar.BRACE_OPEN,
+                closeDelimiter = TokenGrammar.BRACE_CLOSE)
+                .forEach {
+                    var docParser: DocParser? = null
+                    var statementTokens = it.toMutableList()
+                    if (statementTokens.isEmpty())
+                        throw ParseException("Invalid statement in: ${tokenValues(tokens)}", this.indexStart)
+
+                    //If doc, extract doc tokens and parse, and remove from statement tokens
+                    if (statementTokens.first().identifier == TokenGrammar.DOC_START) {
+                        val idx = statementTokens.indexOfFirst { it.identifier == TokenGrammar.DOC_END }
+                        if (idx == -1) throw ParseException("Unable to find doc_end", this.indexStart)
+                        val docTokens = statementTokens.subList(0, idx+1)
+                        docParser = DocParser(docTokens.listIterator())
+                        statementTokens = statementTokens.subList(idx+1, statementTokens.size)
+                    }
+
+                    if (statementTokens.isEmpty())
+                        throw ParseException("Invalid statement in: ${tokenValues(tokens)}", this.indexStart)
+
+                    when(statementTokens.first().identifier) {
+                        TokenGrammar.STRUCT, TokenGrammar.UNION -> {
+                            assert(statementTokens.first().category == TokenCategory.TypeDef)
+                            this.members.add(CompoundMemberDeclaration(
+                                    typeDef = statementTokens.first().identifier,
+                                    type = statementTokens.get(1).value,
+                                    name = statementTokens.last().value,
+                                    docParser = docParser,
+                                    tokens = statementTokens.subList(2, statementTokens.size-1)
+                            ))
+                        }
+                        TokenGrammar.ENUM -> {
+                            assert(statementTokens.size > 1)
+                            this.members.add(MemberDeclaration(
+                                    type = statementTokens.first().value,
+                                    name = statementTokens.get(1).value,
+                                    docParser = docParser,
+                                    tokens = statementTokens
+                            ))
+                        }
+                        else -> {
+                            this.members.add(MemberDeclaration(
+                                    type = statementTokens.first().value,
+                                    name = statementTokens.last().value,
+                                    docParser = docParser,
+                                    tokens = statementTokens
+                            ))
+                        }
+                    }
+                }
+    }
+}
+
+interface IMemberDeclaration {
+    val type: String
+    val name: String
+    val docParser: DocParser?
+    val tokens: List<Token> //TODO: doesn't seem needed
+}
+
+class MemberDeclaration(override val type: String,
+                        override val name: String,
+                        override val docParser: DocParser?,
+                        override val tokens: List<Token>) : IMemberDeclaration
+
+class CompoundMemberDeclaration(override val type: String,
+                                override val name: String,
+                                override val docParser: DocParser?,
+                                override val tokens: List<Token>,
+                                val typeDef: TokenGrammar) : IMemberDeclaration
diff --git a/docs/src/parser/elements/declarations/EnumDeclarationParser.kt b/docs/src/parser/elements/declarations/EnumDeclarationParser.kt
new file mode 100644
index 0000000..fb0fe64
--- /dev/null
+++ b/docs/src/parser/elements/declarations/EnumDeclarationParser.kt
@@ -0,0 +1,105 @@
+/*
+ * Copyright (C) 2017 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.
+ */
+
+package parser.elements.declarations
+
+import lexer.Token
+import lexer.TokenCategory
+import lexer.TokenGrammar
+import parser.elements.DocParser
+import parser.peekToken
+import writer.tokenValues
+import java.text.ParseException
+
+class EnumDeclarationParser(iter: ListIterator<Token>, var shouldResetIterator: Boolean = false) : AbstractDeclarationParser(iter) {
+
+    lateinit override var name: String
+    lateinit var type: String
+    var members = mutableListOf<EnumMember>()
+
+    init {
+        parseTokens(scanTokens(iter))
+        if (shouldResetIterator) resetIterator(iter)
+    }
+
+    override fun parseTokens(tokens: List<Token>) {
+        val iter = tokens.listIterator()
+        var token = iter.next()
+        assert(token.identifier == TokenGrammar.ENUM)
+        assert(tokens.last().identifier == TokenGrammar.SEMICOLON)
+
+        //name
+        token = iter.next()
+        if (token.category != TokenCategory.Word)
+            throw ParseException("Invalid enum name: ${tokenValues(tokens)}", this.indexStart)
+        this.name = token.value
+
+        token = iter.next() //':'
+        if (token.identifier != TokenGrammar.COLON)
+            throw ParseException("Invalid enum type syntax: ${tokenValues(tokens)}", this.indexStart)
+
+        //type: can be type name or package
+        assert(iter.hasNext())
+        val sb = StringBuilder()
+        while (iter.hasNext() && peekToken(iter)!!.identifier != TokenGrammar.BRACE_OPEN) {
+            sb.append(iter.next().value)
+        }
+        this.type = sb.toString()
+
+        //members
+        //convert iterator sequence of comma separated tokens to list of lists
+        scanDelimitedList(iter, openDelimiter = TokenGrammar.BRACE_OPEN, closeDelimiter = TokenGrammar.BRACE_CLOSE)
+                .forEach {
+                    var statementTokens = it.toMutableList()
+                    var docParser: DocParser? = null
+                    assert(statementTokens.isNotEmpty())
+
+                    //If doc, extract doc tokens and parse, and remove from statement tokens
+                    if (statementTokens.first().identifier == TokenGrammar.DOC_START) {
+                        val idx = statementTokens.indexOfFirst { it.identifier == TokenGrammar.DOC_END }
+                        if (idx == -1) throw ParseException("Unable to find doc_end", this.indexStart)
+
+                        val docTokens = statementTokens.subList(0, idx+1)
+                        docParser = DocParser(docTokens.listIterator())
+                        statementTokens = statementTokens.subList(idx+1, statementTokens.size)
+                    }
+                    if (statementTokens.isEmpty())
+                        throw ParseException("Invalid member in enum: ${tokenValues(tokens)}", this.indexStart)
+                    val member = EnumMember(statementTokens)
+                    member.docParser = docParser
+                    this.members.add(member)
+                }
+    }
+}
+
+//split member: name [= value]
+class EnumMember(tokens: List<Token>) {
+    val name: String
+    var value: String? = null
+    var docParser: DocParser? = null
+
+    init {
+        assert(tokens.isNotEmpty())
+        this.name = tokens.first().value
+
+        //check for assignment, take right side
+        if (tokens.any { it.identifier == TokenGrammar.EQUAL }) {
+            this.value = tokens.takeLastWhile { it.identifier != TokenGrammar.EQUAL }
+                    .map { it.value }
+                    .joinToString(" ")
+        }
+    }
+}
\ No newline at end of file
diff --git a/docs/src/parser/elements/declarations/InterfaceDeclarationParser.kt b/docs/src/parser/elements/declarations/InterfaceDeclarationParser.kt
new file mode 100644
index 0000000..ac22c16
--- /dev/null
+++ b/docs/src/parser/elements/declarations/InterfaceDeclarationParser.kt
@@ -0,0 +1,53 @@
+/*
+ * Copyright (C) 2017 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.
+ */
+
+package parser.elements.declarations
+
+import lexer.Token
+import lexer.TokenCategory
+import lexer.TokenGrammar
+
+class InterfaceDeclarationParser(iter: ListIterator<Token>, var shouldResetIterator: Boolean = false) : AbstractDeclarationParser(iter) {
+
+    lateinit override var name: String
+    var extendsName: String? = null
+    var extendsVersion: Float? = null
+
+    init {
+        parseTokens(scanTokens(iter))
+        if (shouldResetIterator) resetIterator(iter)
+    }
+
+    // example format: interface ITunerCallback extends @1.0::ITunerCallback
+    override fun parseTokens(tokens: List<Token>) {
+        assert(tokens.isNotEmpty())
+        assert(tokens.first().identifier == TokenGrammar.INTERFACE)
+        assert(tokens.last().identifier == TokenGrammar.SEMICOLON)
+
+        //grab first line of declarationParser
+        val sigToks = tokens.takeWhile { it.identifier != TokenGrammar.BRACE_OPEN }
+        assert(sigToks[1].category == TokenCategory.Word)
+        assert(sigToks.last().category == TokenCategory.Word) //either interface name or extends name
+
+        this.name = sigToks[1].value
+
+        //parse extends info (if exists)
+        if (sigToks.any { it.identifier == TokenGrammar.EXTENDS }) {
+            this.extendsName = sigToks.last().value
+            this.extendsVersion = sigToks.find { it.category == TokenCategory.Number }?.value?.toFloat()
+        }
+    }
+}
\ No newline at end of file
diff --git a/docs/src/parser/elements/declarations/MethodDeclarationParser.kt b/docs/src/parser/elements/declarations/MethodDeclarationParser.kt
new file mode 100644
index 0000000..beb80a7
--- /dev/null
+++ b/docs/src/parser/elements/declarations/MethodDeclarationParser.kt
@@ -0,0 +1,95 @@
+/*
+ * Copyright (C) 2017 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.
+ */
+
+package parser.elements.declarations
+
+import lexer.Token
+import lexer.TokenCategory
+import lexer.TokenGrammar
+import writer.tokenValues
+import java.text.ParseException
+
+data class ArgEntry(val type: String, val name: String)
+
+class MethodDeclarationParser(iter: ListIterator<Token>, var shouldResetIterator: Boolean = false) : AbstractDeclarationParser(iter) {
+    lateinit override var name: String
+
+    var prefix: String? = null
+    var params = mutableListOf<ArgEntry>()
+    var returns = mutableListOf<ArgEntry>()
+
+    init {
+        parseTokens(scanTokens(iter))
+        if (shouldResetIterator) resetIterator(iter)
+    }
+
+    // [prefix] <name> ( [typedef] [name], ...) [generates] ( [typedef], [name], ...);
+    override fun parseTokens(tokens: List<Token>) {
+        assert(tokens.last().identifier == TokenGrammar.SEMICOLON)
+        val iter = tokens.listIterator()
+        var token = iter.next()
+
+        //grab prefix (typedef or keyword), if there
+        if (token.category == TokenCategory.TypeDef || token.category == TokenCategory.Keyword) {
+            this.prefix = token.value
+            token = iter.next()
+        }
+
+        //name
+        if (token.category != TokenCategory.Word) {
+            throw ParseException("Invalid declarationParser name: '${token.value}'\nBad Tokens: ${tokenValues(tokens)}",
+                    this.indexStart)
+        }
+        this.name = token.value
+
+        assert(iter.hasNext())
+        token = iter.next()
+
+        //parse arg list
+        if (token.identifier == TokenGrammar.PAREN_OPEN) {
+            addArgs(iter, this.params)
+            assert(iter.hasNext())
+            token = iter.next()
+        }
+
+        //parse return list
+        if (token.identifier == TokenGrammar.GENERATES) {
+            addArgs(iter, this.returns)
+            assert(iter.hasNext())
+            token = iter.next()
+        }
+
+        assert(token.identifier == TokenGrammar.SEMICOLON)
+    }
+
+    /**
+     * Arguments are provided in the form: (type1 name1, type2 name2, ...)
+     */
+    private fun addArgs(iter: ListIterator<Token>, list: MutableList<ArgEntry>) {
+        val argLists = this.scanDelimitedList(iter) //return list of list<token>
+        for (argList in argLists) {
+            list.add(formatArgEntry(argList)) //use tokens to create ArgEntry
+        }
+    }
+
+    private fun formatArgEntry(paramTokens: List<Token>): ArgEntry {
+        val type = paramTokens.takeWhile { it != paramTokens.last() } //but-last
+                .map { it.value }
+                .joinToString("")
+        val name = paramTokens.last().value
+        return ArgEntry(type, name)
+    }
+}
\ No newline at end of file
diff --git a/docs/src/parser/elements/declarations/TypedefDeclarationParser.kt b/docs/src/parser/elements/declarations/TypedefDeclarationParser.kt
new file mode 100644
index 0000000..fa3574b
--- /dev/null
+++ b/docs/src/parser/elements/declarations/TypedefDeclarationParser.kt
@@ -0,0 +1,39 @@
+/*
+ * Copyright (C) 2017 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.
+ */
+
+package parser.elements.declarations
+
+import lexer.Token
+import lexer.TokenGrammar
+
+class TypedefDeclarationParser(iter: ListIterator<Token>, var shouldResetIterator: Boolean = false) : AbstractDeclarationParser(iter) {
+    lateinit override var name: String //synonym
+    lateinit var type: String          //type declarationParser
+
+    init {
+        parseTokens(scanTokens(iter))
+        if (shouldResetIterator) resetIterator(iter)
+    }
+
+    override fun parseTokens(tokens: List<Token>) {
+        assert(tokens.isNotEmpty())
+        assert(tokens.first().identifier == TokenGrammar.TYPEDEF)
+        assert(tokens.last().identifier == TokenGrammar.SEMICOLON)
+
+        this.name = tokens.get(tokens.size - 2).value
+        this.type = tokens.subList(1, tokens.size - 2).map { it.value }.joinToString("")
+    }
+}
\ No newline at end of file
diff --git a/docs/src/parser/files/AbstractFileParser.kt b/docs/src/parser/files/AbstractFileParser.kt
new file mode 100644
index 0000000..5348dfd
--- /dev/null
+++ b/docs/src/parser/files/AbstractFileParser.kt
@@ -0,0 +1,133 @@
+/*
+ * Copyright (C) 2017 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.
+ */
+
+package parser.files
+
+import lexer.Token
+import lexer.TokenCategory
+import lexer.TokenGrammar
+import parser.elements.EntryCollectionParser
+import parser.elements.EntryParser
+import parser.elements.declarations.CompoundDeclarationParser
+import parser.elements.declarations.EnumDeclarationParser
+import parser.elements.declarations.TypedefDeclarationParser
+import parser.peekPreviousToken
+import parser.peekToken
+import java.text.ParseException
+
+/**
+ * Parses package info and all entries (determined by doc start/end tokens).
+ * Adds empty doc tokens for required types.
+ * This class shouldn't be instantiated on it's own.
+ */
+abstract class AbstractFileParser(tokens: List<Token>) {
+
+    private val packageInfo: PackageInfo by lazy { parsePackageInfo(tokens) }
+
+    abstract val name: String
+    val packageName: String get() = packageInfo.name
+    val packageVersion: Float get() = packageInfo.version
+
+    protected val entries: List<EntryParser> by lazy {
+        assert(tokens.isNotEmpty())
+        //add empty docblocks
+        EntryCollectionParser(insertDocsForRequiredTypes(tokens)).entryParsers
+    }
+
+    val enums: List<EntryParser> by lazy { getEntriesByDeclarationParser<EnumDeclarationParser>() }
+    val typedefs: List<EntryParser> by lazy { getEntriesByDeclarationParser<TypedefDeclarationParser>() }
+    val structs: List<EntryParser> by lazy { getEntriesByCompoundDeclarationParser(TokenGrammar.STRUCT) }
+    val unions: List<EntryParser> by lazy { getEntriesByCompoundDeclarationParser(TokenGrammar.UNION) }
+
+    protected inline fun <reified T> getEntriesByDeclarationParser(): List<EntryParser> {
+        return entries.filter { it.declarationParser is T }
+    }
+
+    private fun getEntriesByCompoundDeclarationParser(identifier: TokenGrammar): List<EntryParser> {
+        return getEntriesByDeclarationParser<CompoundDeclarationParser>()
+                .filter { (it.declarationParser as CompoundDeclarationParser).type == identifier }
+    }
+
+    private val REQUIRED_DOC_TYPES = listOf(
+            TokenGrammar.INTERFACE,
+            TokenGrammar.ENUM,
+            TokenGrammar.STRUCT,
+            TokenGrammar.UNION,
+            TokenGrammar.TYPEDEF)
+
+    /**
+     * Insert doc block before the undocumented types we want to show up.
+     */
+    private fun insertDocsForRequiredTypes(tokens: List<Token>): List<Token> {
+        val tokensCopy = mutableListOf<Token>()
+        val iter = tokens.listIterator()
+        var token: Token
+        var inDoc = false
+
+        while (iter.hasNext()) {
+            token = iter.next()
+            tokensCopy.add(token)
+
+            if (token.identifier == TokenGrammar.DOC_START) {
+                inDoc = true
+                continue
+            } else if (token.identifier == TokenGrammar.DOC_END) {
+                inDoc = false
+                continue
+
+            } else if (!inDoc && token.identifier in REQUIRED_DOC_TYPES) {
+                //make sure it's not a reference to a Generic: <name>
+                if (peekToken(iter)?.identifier == TokenGrammar.CHEVRON_CLOSE) {
+                    continue
+                }
+
+                val idx = indexInsertionPointforDocTokens(tokensCopy)
+                if (idx != -1) {
+                    val removedTokens = mutableListOf<Token>()
+                    repeat(idx) {
+                        removedTokens.add(tokensCopy.removeAt(tokensCopy.size-1))
+                    }
+                    tokensCopy.add(TokenGrammar.newToken(TokenGrammar.DOC_START.value))
+                    tokensCopy.add(TokenGrammar.newToken(TokenGrammar.DOC_END.value))
+                    removedTokens.reversed().forEach { tokensCopy.add(it) }
+                }
+            }
+        }
+        return tokensCopy.toList()
+    }
+
+    /**
+     * @return -1 if documented, otherwise the index count backwards for where
+     *          to begin insertion of doc tokens.
+     */
+    private fun indexInsertionPointforDocTokens(tokens: List<Token>): Int {
+        val iter = tokens.reversed().listIterator()
+        var token: Token
+        var idx = 0
+
+        iter.next() //skip keyword token
+        while (iter.hasNext()) {
+            token = iter.next()
+            if (token.identifier == TokenGrammar.AT || token.category == TokenCategory.Annotation) {
+                idx++
+                continue //skip annotations
+            } else {
+                return if (token.identifier == TokenGrammar.DOC_END) -1 else idx+1
+            }
+        }
+        throw ParseException("Empty token list", 0)
+    }
+}
\ No newline at end of file
diff --git a/docs/src/parser/files/InterfaceFileParser.kt b/docs/src/parser/files/InterfaceFileParser.kt
new file mode 100644
index 0000000..d68b12c
--- /dev/null
+++ b/docs/src/parser/files/InterfaceFileParser.kt
@@ -0,0 +1,81 @@
+/*
+ * Copyright (C) 2017 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.
+ */
+
+package parser.files
+
+import lexer.Token
+import lexer.TokenCategory
+import lexer.TokenGrammar
+import parser.elements.AnnotationParser
+import parser.elements.EntryParser
+import parser.elements.declarations.InterfaceDeclarationParser
+import parser.elements.declarations.MethodDeclarationParser
+
+class InterfaceFileParser(tokens: List<Token>) : AbstractFileParser(tokens) {
+
+    private val interfaceEntry: EntryParser by lazy {
+        //returns first matching element (i don't think there can be multiple interface declarations)
+        this.entries.find { it.declarationParser is InterfaceDeclarationParser }
+                ?: throw ClassNotFoundException("Unable to find an InterfaceDeclarationParser")
+    }
+    //need this for the cast
+    private val interfaceDecl: InterfaceDeclarationParser by lazy {
+        interfaceEntry.declarationParser as InterfaceDeclarationParser
+    }
+
+    /* top-level properties on the interface itself, ie. not its entries */
+
+    override val name: String get() = interfaceDecl.name
+    val extendsName: String? get() = interfaceDecl.extendsName
+    val extendsVersion: Float? get() = interfaceDecl.extendsVersion
+
+    //doc
+    val description get() = interfaceEntry.docParser.description
+    val docAnnotations get() = interfaceEntry.docParser.docAnnotationParsers //tag, arg?, description
+
+    val annotations: List<AnnotationParser> get() = interfaceEntry.annotationParsers //name, value
+    val methods: List<EntryParser> by lazy { getEntriesByDeclarationParser<MethodDeclarationParser>() }
+
+    companion object {
+        /**
+         * Searches tokens for an interface identifier.
+         * Maybe not the most accurate measurement, but good enough.
+         */
+        fun isInterface(tokens: List<Token>): Boolean {
+            val iter = tokens.listIterator()
+            var token: Token
+            var inDoc = false
+
+            while (iter.hasNext()) {
+                token = iter.next()
+                if (token.identifier == TokenGrammar.DOC_START) {
+                    inDoc = true
+                    continue
+                } else if (token.identifier == TokenGrammar.DOC_END) {
+                    inDoc = false
+                    continue
+
+                } else if (!inDoc && token.identifier == TokenGrammar.INTERFACE) {
+                    if (iter.next().category != TokenCategory.Word) break //no, try again
+
+                    return true
+                }
+            }
+            return false
+        }
+
+    }
+}
\ No newline at end of file
diff --git a/test/error_test/no_interface_in_types/error/1.0/IFoo.hal b/docs/src/parser/files/TypesFileParser.kt
similarity index 79%
copy from test/error_test/no_interface_in_types/error/1.0/IFoo.hal
copy to docs/src/parser/files/TypesFileParser.kt
index d79e6ab..a903a6a 100644
--- a/test/error_test/no_interface_in_types/error/1.0/IFoo.hal
+++ b/docs/src/parser/files/TypesFileParser.kt
@@ -13,7 +13,11 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-package test.error.error@1.0;
 
-interface IFoo {
-};
\ No newline at end of file
+package parser.files
+
+import lexer.Token
+
+class TypesFileParser(tokens: List<Token>) : AbstractFileParser(tokens) {
+    override val name = "types"
+}
\ No newline at end of file
diff --git a/docs/src/parser/files/package.kt b/docs/src/parser/files/package.kt
new file mode 100644
index 0000000..5b1cb81
--- /dev/null
+++ b/docs/src/parser/files/package.kt
@@ -0,0 +1,63 @@
+/*
+ * Copyright (C) 2017 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.
+ */
+
+package parser.files
+
+import lexer.Token
+import lexer.TokenCategory
+import lexer.TokenGrammar
+import java.text.ParseException
+
+data class PackageInfo(val name: String, val version: Float)
+
+/**
+ * Find and parse package info. Throw error if it can't find a valid declarationParser format.
+ * Example format: package android.hardware.audio@2.0;
+ */
+fun parsePackageInfo(tokens: List<Token>): PackageInfo {
+    val iter: ListIterator<Token> = tokens.listIterator()
+    var token: Token
+
+    while (iter.hasNext()) {
+        token = iter.next()
+
+        if (token.identifier == TokenGrammar.PACKAGE) {
+            //collect namespace
+            val pkgNameToks = mutableListOf<Token>()
+            while (iter.hasNext()) {
+                token = iter.next()
+                if (token.identifier != TokenGrammar.AT && token.identifier != TokenGrammar.SEMICOLON) {
+                    pkgNameToks.add(token)
+                } else {
+                    break
+                }
+            }
+            val pkgName = pkgNameToks.map { it.value }.joinToString("")
+
+            //step through format and test syntax
+            if (token.identifier != TokenGrammar.AT) break
+            token = iter.next()
+            if (token.category != TokenCategory.Number) break //version
+            val pkgVer = token.value.toFloat()
+            token = iter.next()
+            if (token.identifier != TokenGrammar.SEMICOLON) break
+
+            //hooray, a proper package format
+            return PackageInfo(pkgName, pkgVer)
+        }
+    }
+    throw ParseException("Unable to find a valid package declaration", 0)
+}
\ No newline at end of file
diff --git a/docs/src/parser/utils.kt b/docs/src/parser/utils.kt
new file mode 100644
index 0000000..77fa3d3
--- /dev/null
+++ b/docs/src/parser/utils.kt
@@ -0,0 +1,42 @@
+/*
+ * Copyright (C) 2017 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.
+ */
+
+package parser
+
+import lexer.Token
+
+/**
+ * Returns the next token in the iteration, without advancing the iteration.
+ */
+fun peekToken(iter: ListIterator<Token>): Token? {
+    if (iter.hasNext()) {
+        val token = iter.next()
+        iter.previous()
+        return token
+    } else {
+        return null
+    }
+}
+
+fun peekPreviousToken(iter: ListIterator<Token>): Token? {
+    if (iter.hasPrevious()) {
+        val token = iter.previous()
+        iter.next()
+        return token
+    } else {
+        return null
+    }
+}
\ No newline at end of file
diff --git a/docs/src/writer/elements/AbstractElement.kt b/docs/src/writer/elements/AbstractElement.kt
new file mode 100644
index 0000000..8be0bae
--- /dev/null
+++ b/docs/src/writer/elements/AbstractElement.kt
@@ -0,0 +1,82 @@
+/*
+ * Copyright (C) 2017 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.
+ */
+
+package writer.elements
+
+import parser.elements.EntryParser
+import parser.elements.declarations.AbstractDeclarationParser
+import writer.formatTextasHTML
+import writer.htmlEscape
+
+abstract class AbstractElement(parser: EntryParser) {
+    protected val docParser = parser.docParser
+    protected val annotationParsers = parser.annotationParsers
+
+    abstract protected val declarationParser: AbstractDeclarationParser //specify in subclass
+    abstract fun declaration(): String
+    abstract fun detailsRows(): String
+
+    open fun toHTML(): String {
+        return """
+<div>
+  <h3>${declarationParser.name}</h3>
+  <pre class="prettyprint devsite-disable-click-to-copy">${declaration()}</pre>
+  <div>
+    ${formatTextasHTML(docParser.description)}
+  </div>
+  <table class="details responsive">
+    <thead>
+      <th colspan="2">Details</th>
+    </thead>
+    <tbody>
+      ${detailsRows()}
+      ${annotationRows()}
+    </tbody>
+  </table>
+</div>
+""".trim()
+    }
+
+    private fun annotationRows(): String {
+        val sb = StringBuilder()
+        if (annotationParsers.isNotEmpty()) {
+            sb.append("""
+            <tr>
+              <td>Annotations</td>
+              <td>
+                <table class="function param responsive">
+                  <tbody>""")
+            //AnnotationParser => name:TokenGrammar, value:String
+            annotationParsers.forEach { arg ->
+                sb.append("""
+                <tr>
+                  <td>
+                    <code>${arg.name.value}</code>
+                  </td>
+                  <td>
+                    <div>${htmlEscape(arg.value)}</div>
+                  </td>
+                </tr>""")
+            }
+            sb.append("""
+                  </tbody>
+                </table>
+              </td>
+            </tr>""")
+        }
+        return sb.toString().trim()
+    }
+}
\ No newline at end of file
diff --git a/docs/src/writer/elements/CompoundElement.kt b/docs/src/writer/elements/CompoundElement.kt
new file mode 100644
index 0000000..d5fc180
--- /dev/null
+++ b/docs/src/writer/elements/CompoundElement.kt
@@ -0,0 +1,72 @@
+/*
+ * Copyright (C) 2017 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.
+ */
+
+package writer.elements
+
+import parser.elements.EntryParser
+import parser.elements.declarations.CompoundDeclarationParser
+import parser.elements.declarations.CompoundMemberDeclaration
+import writer.formatTextasHTML
+
+// used for structs and unions
+class CompoundElement(parser: EntryParser): AbstractElement(parser) {
+    //type, name, members [IMemberDeclaration]
+    override val declarationParser = parser.declarationParser as CompoundDeclarationParser
+
+    override fun declaration(): String {
+        val sb = StringBuilder()
+        sb.append("${declarationParser.type.value} ${declarationParser.name} {")
+        declarationParser.members.forEachIndexed { i, arg ->
+            val typedef = if (arg is CompoundMemberDeclaration) "${arg.typeDef.value} " else ""
+            sb.append("${typedef}${arg.type} ${arg.name}")
+            if (i < declarationParser.members.size-1) sb.append("; ")
+        }
+        sb.append("}")
+        return sb.toString()
+    }
+
+    override fun detailsRows(): String {
+        //build member rows
+        val sb = StringBuilder()
+        if (declarationParser.members.isNotEmpty()) {
+            sb.append("""
+            <tr>
+              <td>Members</td>
+              <td>
+                <table class="function param responsive">
+                  <tbody>""")
+            //type, name, tokens, typedef
+            declarationParser.members.forEach { arg ->
+                val fieldDesc = arg.docParser?.description?.let { formatTextasHTML(it, useParagraphs = false) } ?: ""
+                sb.append("""
+                <tr>
+                  <td>
+                    <code>${arg.name}</code>
+                  </td>
+                  <td>
+                    <div>${fieldDesc}</div>
+                  </td>
+                </tr>""")
+            }
+            sb.append("""
+                  </tbody>
+                </table>
+              </td>
+            </tr>""")
+        }
+        return sb.toString()
+    }
+}
\ No newline at end of file
diff --git a/docs/src/writer/elements/EnumElement.kt b/docs/src/writer/elements/EnumElement.kt
new file mode 100644
index 0000000..42d03fe
--- /dev/null
+++ b/docs/src/writer/elements/EnumElement.kt
@@ -0,0 +1,64 @@
+/*
+ * Copyright (C) 2017 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.
+ */
+
+package writer.elements
+
+import parser.elements.EntryParser
+import parser.elements.declarations.EnumDeclarationParser
+import writer.formatTextasHTML
+import writer.htmlEscape
+
+class EnumElement(parser: EntryParser) : AbstractElement(parser) {
+    //name [String], type [String], members [EnumMember: name, value?]
+    override val declarationParser = parser.declarationParser as EnumDeclarationParser
+
+    override fun declaration(): String {
+        return "enum ${declarationParser.name}: ${declarationParser.type}"
+    }
+
+    override fun detailsRows(): String {
+        //build member rows
+        val sb = StringBuilder()
+        if (declarationParser.members.isNotEmpty()) {
+            sb.append("""
+            <tr>
+              <td>Members</td>
+              <td>
+                <table class="function param responsive">
+                  <tbody>""")
+            //EnumMember => name, value?
+            declarationParser.members.forEach { arg ->
+                val fieldVal = arg.value?.let { " = ${htmlEscape(it)}" } ?: ""
+                val fieldDesc = arg.docParser?.description?.let { formatTextasHTML(it, useParagraphs = false) } ?: ""
+                sb.append("""
+                <tr>
+                  <td>
+                    <code>${htmlEscape(arg.name)}${fieldVal}</code>
+                  </td>
+                  <td>
+                    <div>$fieldDesc</div>
+                  </td>
+                </tr>""")
+            }
+            sb.append("""
+                  </tbody>
+                </table>
+              </td>
+            </tr>""")
+        }
+        return sb.toString().trim()
+    }
+}
\ No newline at end of file
diff --git a/docs/src/writer/elements/MethodElement.kt b/docs/src/writer/elements/MethodElement.kt
new file mode 100644
index 0000000..dcd6c2a
--- /dev/null
+++ b/docs/src/writer/elements/MethodElement.kt
@@ -0,0 +1,157 @@
+/*
+ * Copyright (C) 2017 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.
+ */
+
+package writer.elements
+
+import lexer.TokenGrammar
+import parser.config
+import parser.elements.EntryParser
+import parser.elements.declarations.ArgEntry
+import parser.elements.declarations.MethodDeclarationParser
+import writer.formatTextasHTML
+import writer.htmlEscape
+import writer.warn
+import java.text.ParseException
+
+class MethodElement(parser: EntryParser) : AbstractElement(parser) {
+    override val declarationParser = parser.declarationParser as MethodDeclarationParser
+
+    //prefix, params, returns
+    override fun declaration(): String {
+        val sb = StringBuilder()
+        declarationParser.prefix?.let { sb.append("${it} ") }
+        sb.append("${declarationParser.name} (")
+        declarationParser.params.forEachIndexed { i, arg ->
+            sb.append(htmlEscape("${arg.type} ${arg.name}"))
+            if (i < declarationParser.params.size-1) sb.append(", ")
+        }
+        sb.append(")")
+        if (declarationParser.returns.isNotEmpty()) {
+            sb.append("\ngenerates (")
+            declarationParser.returns.forEachIndexed { i, arg ->
+                sb.append(htmlEscape("${arg.type} ${arg.name}"))
+                if (i < declarationParser.returns.size-1) sb.append(", ")
+            }
+            sb.append(")")
+        }
+        return sb.toString()
+    }
+
+    override fun detailsRows(): String {
+        return """
+${buildPrefixRows()}
+${buildParamRows()}
+${buildReturnRows()}
+""".trim()
+    }
+
+    private fun getDocAnnotationDesc(tag: TokenGrammar, arg: ArgEntry): String {
+        return docParser.docAnnotationParsers
+                .filter { it.tag == tag }
+                .firstOrNull { it.arg == arg.name }
+                ?.let { formatTextasHTML(it.description, useParagraphs = false) }
+                ?: run {
+            val msg = "Missing @${tag.value} doc annotation for '${arg.type} ${arg.name}'"
+            if (config.errorOnly) {
+                throw ParseException(msg, 0)
+            } else {
+                warn(msg)
+                "" //return empty string if it can't find it
+            }
+        }
+    }
+
+    private fun buildPrefixRows(): String {
+        val sb = StringBuilder()
+        if (declarationParser.prefix != null) {
+            sb.append("""
+            <tr>
+              <td>RPC mode</td>
+              <td>
+                <table class="function param responsive">
+                  <tbody>
+                    <tr>
+                      <td>
+                        <code>${declarationParser.prefix}</code>
+                      </td>
+                    </tr>
+                  </tbody>
+                </table>
+              </td>
+            </tr>""")
+        }
+        return sb.toString()
+    }
+
+    private fun buildParamRows(): String {
+        //docParser.docAnnotationParsers //=> tag [TokenGrammer], arg?, description
+        val sb = StringBuilder()
+        if (declarationParser.params.isNotEmpty()) {
+            sb.append("""
+            <tr>
+              <td>Parameters</td>
+              <td>
+                <table class="function param responsive">
+                  <tbody>""")
+            declarationParser.params.forEach { arg ->
+                sb.append("""
+                <tr>
+                  <td>
+                    <code>${htmlEscape(arg.name)}</code>
+                  </td>
+                  <td>
+                    <div>${getDocAnnotationDesc(TokenGrammar.PARAM, arg)}</div>
+                  </td>
+                </tr>""")
+            }
+            sb.append("""
+                  </tbody>
+                </table>
+              </td>
+            </tr>""")
+        }
+        return sb.toString()
+    }
+
+    private fun buildReturnRows(): String {
+        val sb = StringBuilder()
+        if (declarationParser.returns.isNotEmpty()) {
+            sb.append("""
+            <tr>
+              <td>Generates</td>
+              <td>
+                <table class="function param responsive">
+                  <tbody>""")
+            declarationParser.returns.forEach { arg ->
+                sb.append("""
+                <tr>
+                  <td>
+                    <code>${htmlEscape(arg.name)}</code>
+                  </td>
+                  <td>
+                    <div>${getDocAnnotationDesc(TokenGrammar.RETURN, arg)}</div>
+                  </td>
+                </tr>""")
+            }
+            sb.append("""
+                  </tbody>
+                </table>
+              </td>
+            </tr>""")
+        }
+        return sb.toString()
+    }
+}
\ No newline at end of file
diff --git a/docs/src/writer/elements/TypedefElement.kt b/docs/src/writer/elements/TypedefElement.kt
new file mode 100644
index 0000000..9dea39a
--- /dev/null
+++ b/docs/src/writer/elements/TypedefElement.kt
@@ -0,0 +1,44 @@
+/*
+ * Copyright (C) 2017 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.
+ */
+
+package writer.elements
+
+import parser.elements.EntryParser
+import parser.elements.declarations.TypedefDeclarationParser
+import writer.formatTextasHTML
+
+class TypedefElement(parser: EntryParser) : AbstractElement(parser) {
+    //name, type
+    override val declarationParser = parser.declarationParser as TypedefDeclarationParser
+
+    override fun declaration(): String {
+        return "typedef ${declarationParser.type} ${declarationParser.name}"
+    }
+
+    override fun detailsRows() = "" //not used
+
+    override fun toHTML(): String {
+        return """
+<div>
+  <h3>${declarationParser.name}</h3>
+  <pre class="prettyprint devsite-disable-click-to-copy">${declaration()}</pre>
+  <div>
+    ${formatTextasHTML(docParser.description)}
+  </div>
+</div>
+""".trim()
+    }
+}
\ No newline at end of file
diff --git a/docs/src/writer/files/AbstractFileWriter.kt b/docs/src/writer/files/AbstractFileWriter.kt
new file mode 100644
index 0000000..0c75688
--- /dev/null
+++ b/docs/src/writer/files/AbstractFileWriter.kt
@@ -0,0 +1,67 @@
+/*
+ * Copyright (C) 2017 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.
+ */
+
+package writer.files
+
+import parser.config
+import java.nio.file.Path
+
+abstract class AbstractFileWriter() {
+    abstract val baseName: String
+    abstract val templateResource: String
+    abstract val path: Path
+
+    //init with template file contents on first use
+    var outStr: String = ""
+        get() = if (field.isEmpty()) resources.readResourceText(this.templateResource) else field
+
+    open fun replaceVars() {}
+
+    fun replaceVar(varName: String, newValue: String) {
+        outStr = outStr.replace(Regex("\\\$\\{?$varName}?"), newValue)
+    }
+
+    fun replaceVar(varName: String, newValue: () -> String) {
+        replaceVar(varName, newValue())
+    }
+
+    fun writeToFile(): Boolean {
+        replaceVars()
+        onWrite()
+
+        if (config.lintMode) {
+            return false
+        } else {
+            val dir = this.path.parent.toFile() //dir name
+            if (!dir.exists()) dir.mkdirs()
+            if (!dir.canWrite()) throw FileSystemException(dir, reason = "No write access to output directory")
+
+            val fp = this.path.toFile()
+            fp.bufferedWriter().use { it.write(this.outStr) }
+            if (!fp.isFile) throw FileSystemException(fp, reason = "Error writing file")
+            return true
+        }
+    }
+
+    open fun onWrite() {}
+
+    open fun printInfo() {
+        println("Name: ${this.baseName}")
+        println(" AbstractFileWriter:")
+        println("  class: ${javaClass.simpleName}")
+        println("  dest: ${this.path}")
+    }
+}
\ No newline at end of file
diff --git a/docs/src/writer/files/AbstractParserFileWriter.kt b/docs/src/writer/files/AbstractParserFileWriter.kt
new file mode 100644
index 0000000..96a54d2
--- /dev/null
+++ b/docs/src/writer/files/AbstractParserFileWriter.kt
@@ -0,0 +1,69 @@
+/*
+ * Copyright (C) 2017 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.
+ */
+
+package writer.files
+
+import parser.config
+import parser.files.AbstractFileParser
+import writer.elements.CompoundElement
+import writer.elements.EnumElement
+import writer.elements.TypedefElement
+import writer.getOutPath
+import java.nio.file.Path
+
+abstract class AbstractParserFileWriter(private val parser: AbstractFileParser) : AbstractFileWriter() {
+
+    override val baseName = parser.name
+    override val templateResource: String by lazy { "/resources/template/${this.baseName}.html" }
+    override val path: Path by lazy { getOutPath(parser, config.outDir) }
+
+    override fun replaceVars() {
+        replaceVar("name", parser.name)
+
+        replaceVar("propertyDefs") {
+            val sb = StringBuilder()
+
+            if (parser.typedefs.isNotEmpty()
+                    || parser.enums.isNotEmpty()
+                    || parser.structs.isNotEmpty()
+                    || parser.unions.isNotEmpty()) {
+                sb.append("<section>\n")
+                sb.append("<h2>Properties</h2>\n")
+                //typedefs
+                sb.append(parser.typedefs.map { TypedefElement(it).toHTML() }.joinToString("\n"))
+                //enums
+                sb.append(parser.enums.map { EnumElement(it).toHTML() }.joinToString("\n"))
+                //structs
+                sb.append(parser.structs.map { CompoundElement(it).toHTML() }.joinToString("\n"))
+                //unions
+                sb.append(parser.unions.map { CompoundElement(it).toHTML() }.joinToString("\n"))
+                sb.append("\n</section>\n")
+            }
+            sb.toString()
+        }
+    }
+
+    override fun printInfo() {
+        super.printInfo()
+        println(" AbstractParserFileWriter:")
+        println("  package: ${parser.packageName}")
+        println("  package ver: ${parser.packageVersion}")
+        println("  enums count: ${parser.enums.size}")
+        println("  structs count: ${parser.structs.size}")
+        println("  unions count: ${parser.unions.size}")
+        println("  typedefs count: ${parser.typedefs.size}")
+    }
+}
\ No newline at end of file
diff --git a/docs/src/writer/files/IndexFileWriter.kt b/docs/src/writer/files/IndexFileWriter.kt
new file mode 100644
index 0000000..3b686d3
--- /dev/null
+++ b/docs/src/writer/files/IndexFileWriter.kt
@@ -0,0 +1,189 @@
+/*
+ * Copyright (C) 2017 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.
+ */
+
+package writer.files
+
+import parser.LOG_NAME
+import parser.config
+import parser.files.AbstractFileParser
+import parser.files.InterfaceFileParser
+import writer.getDescSummaryText
+import writer.getOutPath
+import java.io.File
+import java.nio.file.Path
+import java.nio.file.Paths
+
+data class EntryData(val fullName: String, //package.BaseName
+                     val baseName: String,
+                     val packageName: String,
+                     val packageVersion: Float,
+                     val summary: String,
+                     val relPath: Path)
+
+class IndexFileWriter : AbstractFileWriter() {
+
+    override val baseName = "index"
+    override val templateResource = "/resources/template/${this.baseName}.html"
+    override val path: Path by lazy { Paths.get("${config.outDir}${File.separator}${this.baseName}.html") }
+
+    private val entries = mutableListOf<EntryData>()
+
+    fun addEntry(parser: AbstractFileParser) {
+        val summaryStr = when (parser) {
+            is InterfaceFileParser -> getDescSummaryText(parser.description)
+            else -> ""
+        }
+        entries.add(EntryData(
+                fullName = "${parser.packageName}.${parser.name}",
+                baseName = parser.name,
+                packageName = parser.packageName,
+                packageVersion = parser.packageVersion,
+                summary = summaryStr,
+                relPath = config.outDir.relativize(getOutPath(parser, config.outDir))
+        ))
+    }
+
+    override fun printInfo() {
+        super.printInfo()
+        println( "IndexFileWriter:")
+        println("  entries: ${this.entries.size}")
+    }
+
+    /*
+     * HTML index file
+     */
+
+    override fun replaceVars() {
+        replaceVar("title", "Index")
+
+        replaceVar("entries") {
+            val sb = StringBuilder()
+            if (entries.isNotEmpty()) {
+                entries.sortWith(EntryNameComparator())
+                sb.append(buildEntryTable())
+            }
+            sb.toString()
+        }
+    }
+
+    private fun buildEntryTable(): String {
+        return """
+<table>
+  <tr>
+    <th>Entry</th>
+    <th>Version</th>
+    <th>Summary</th>
+  </tr>
+${entries.map { buildClassEntry(it) }.joinToString("\n")}
+</table>
+""".trim()
+    }
+
+    private fun buildClassEntry(entry: EntryData): String {
+        return """
+<tr>
+  <td>
+<a href="${entry.relPath}">${entry.fullName}</a>
+  </td>
+  <td>
+${entry.packageVersion}
+  </td>
+  <td>
+${entry.summary}
+  </td>
+</tr>
+""".trim()
+    }
+
+    private class EntryNameComparator : Comparator<EntryData> {
+        override fun compare(entry1: EntryData, entry2: EntryData): Int {
+            return if (entry1.fullName != entry2.fullName) {
+                //sort on name first, alphabetic
+                when {
+                    entry1.fullName < entry2.fullName -> -1
+                    entry1.fullName > entry2.fullName -> 1
+                    else -> 0
+                }
+            } else {
+                //if same name, reverse sort on pkg version (highest first)
+                when {
+                    entry1.packageVersion < entry2.packageVersion -> 1
+                    entry1.packageVersion > entry2.packageVersion -> -1
+                    else -> 0
+                }
+            }
+        }
+    }
+
+    /*
+     * YAML toc file
+     */
+
+    private val tocFileName = "_book.yaml"
+    private val tocFileRelPath = "/reference/hidl"
+    private val tocOutPath: Path by lazy { Paths.get("${config.outDir}${File.separator}${this.tocFileName}") }
+
+    //write toc yaml file after html index
+    override fun onWrite() {
+        super.onWrite()
+        if (!config.lintMode) {
+            val fp = tocOutPath.toFile()
+            fp.bufferedWriter().use {
+                it.write(buildTocHeader())
+                it.write(buildTocEntries(collectPackages()))
+            }
+            if (!fp.isFile) throw FileSystemException(fp, reason = "Error writing file")
+            println("$LOG_NAME Wrote toc: $tocOutPath")
+        }
+    }
+
+    private fun buildTocHeader(): String {
+        return """
+# Generated by hidl-doc
+toc:
+- title: Index
+  path: $tocFileRelPath
+""".trimStart()
+    }
+
+    private fun buildTocEntries(pkgEntries: Map<String, List<EntryData>>): String {
+        val sb = StringBuilder()
+
+        for ((pkgName, entryList) in pkgEntries) {
+            sb.append("- title: $pkgName\n  section:\n")
+
+            entryList.forEach { entry ->
+                sb.append("  - title: ${entry.baseName} @${entry.packageVersion}\n")
+                sb.append("    path: ${tocFileRelPath}/${entry.relPath}\n")
+            }
+        }
+        return sb.toString()
+    }
+
+    private fun collectPackages(): Map<String, List<EntryData>> {
+        val pkgEntries = mutableMapOf<String, MutableList<EntryData>>()
+
+        this.entries.forEach { entry ->
+            if (pkgEntries.containsKey(entry.packageName)) {
+                pkgEntries[entry.packageName]!!.add(entry)
+            } else {
+                pkgEntries[entry.packageName] = mutableListOf(entry)
+            }
+        }
+        //sort on package name. entries *should* already be sorted
+        return pkgEntries.toSortedMap()
+    }
+}
\ No newline at end of file
diff --git a/docs/src/writer/files/InterfaceFileWriter.kt b/docs/src/writer/files/InterfaceFileWriter.kt
new file mode 100644
index 0000000..a0fefa6
--- /dev/null
+++ b/docs/src/writer/files/InterfaceFileWriter.kt
@@ -0,0 +1,74 @@
+/*
+ * Copyright (C) 2017 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.
+ */
+
+package writer.files
+
+import parser.files.InterfaceFileParser
+import writer.elements.MethodElement
+import writer.formatTextasHTML
+
+class InterfaceFileWriter(private val parser: InterfaceFileParser) : AbstractParserFileWriter(parser) {
+
+    override var templateResource = "/resources/template/interface.html"
+
+    override fun replaceVars() {
+        super.replaceVars()
+        replaceVar("header", buildHeader())
+
+        replaceVar("methodDefs") {
+            val sb = StringBuilder()
+            if (parser.methods.isNotEmpty()) {
+                sb.append("<section>\n")
+                sb.append("<h2>Methods</h2>\n")
+                sb.append(parser.methods.map { MethodElement(it).toHTML() }.joinToString("\n"))
+                sb.append("\n</section>\n")
+            }
+            sb.toString()
+        }
+    }
+
+    private fun buildHeader(): String {
+        return """
+<header>
+  <div id="api-info-block">
+    Package: <code>${parser.packageName}@${parser.packageVersion}</code>
+  </div>
+  <h1>${parser.name}</h1>
+  <code>${buildDeclaration()}</code>
+  ${formatTextasHTML(parser.description)}
+</header>
+""".trim()
+    }
+
+    private fun buildDeclaration(): String {
+        val sb = StringBuilder()
+        sb.append("interface ${parser.name}")
+        if (parser.extendsName != null) {
+            sb.append(" extends ")
+            if (parser.extendsVersion != null) sb.append("@${parser.extendsVersion}::")
+            sb.append(parser.extendsName)
+        }
+        return sb.toString()
+    }
+
+    override fun printInfo() {
+        super.printInfo()
+        println(" InterfaceFileWriter:")
+        println("  Interface: ${parser.name} extends ${parser.extendsName}::${parser.extendsVersion}")
+        val methodEntries = parser.methods.map { MethodElement(it) }
+        println("  method count: ${methodEntries.size}")
+    }
+}
\ No newline at end of file
diff --git a/docs/src/writer/files/TypesFileWriter.kt b/docs/src/writer/files/TypesFileWriter.kt
new file mode 100644
index 0000000..85b9a60
--- /dev/null
+++ b/docs/src/writer/files/TypesFileWriter.kt
@@ -0,0 +1,40 @@
+/*
+ * Copyright (C) 2017 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.
+ */
+
+package writer.files
+
+import parser.files.TypesFileParser
+
+class TypesFileWriter(private val parser: TypesFileParser) : AbstractParserFileWriter(parser) {
+
+    override var templateResource = "/resources/template/types.html"
+
+    override fun replaceVars() {
+        super.replaceVars()
+        replaceVar("header", buildHeader())
+    }
+
+    private fun buildHeader(): String {
+        return """
+<header>
+  <div id="api-info-block">
+    Package: <code>${parser.packageName}@${parser.packageVersion}</code>
+  </div>
+  <h1>${parser.name}</h1>
+</header>
+""".trim()
+    }
+}
\ No newline at end of file
diff --git a/docs/src/writer/files/resources.kt b/docs/src/writer/files/resources.kt
new file mode 100644
index 0000000..25ba4b8
--- /dev/null
+++ b/docs/src/writer/files/resources.kt
@@ -0,0 +1,54 @@
+/*
+ * Copyright (C) 2017 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.
+ */
+
+package writer.files
+
+import parser.config
+import java.io.FileNotFoundException
+import java.nio.file.Path
+
+object resources {
+
+    private val resourceCache = mutableMapOf<String, String>() //name(path) => contents
+
+    fun readResourceText(name: String): String {
+        return resourceCache.getOrElse(name) {
+            val input = javaClass.getResourceAsStream(name)
+                    ?: throw FileNotFoundException("Unable to locate file resource: $name")
+
+            val contents = input.bufferedReader().use { it.readText() }
+            resourceCache[name] = contents
+            contents
+        }
+    }
+
+    fun copyToFile(resourceName: String, outPath: Path): Boolean {
+        val contents = readResourceText(resourceName)
+
+        if (config.lintMode) {
+            return false
+        } else {
+            val dir = outPath.parent.toFile() //dir name
+            if (!dir.exists()) dir.mkdirs()
+            if (!dir.canWrite()) throw FileSystemException(dir, reason = "No write access to output directory")
+
+            val fp = outPath.toFile()
+            fp.bufferedWriter().use { it.write(contents) }
+            if (!fp.isFile) throw FileSystemException(fp, reason = "Error writing file")
+            return true
+        }
+    }
+}
\ No newline at end of file
diff --git a/docs/src/writer/formatutils.kt b/docs/src/writer/formatutils.kt
new file mode 100644
index 0000000..8afeb6d
--- /dev/null
+++ b/docs/src/writer/formatutils.kt
@@ -0,0 +1,91 @@
+/*
+ * Copyright (C) 2017 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.
+ */
+
+package writer
+
+import lexer.Token
+import parser.files.AbstractFileParser
+import java.io.File
+import java.nio.file.Path
+import java.nio.file.Paths
+
+fun warn(msg: String) {
+    System.err.println("WARNING: $msg")
+}
+
+/**
+ * Get values of tokens, useful for debugging.
+ */
+fun tokenValues(tokens: List<Token>): String {
+    return tokens.map { it.value }.joinToString("|")
+}
+
+/**
+ * Escape string for HTML.
+ */
+fun htmlEscape(string: String): String {
+    val out = StringBuilder(Math.max(16, string.length))
+    string.toCharArray().forEach { c ->
+        if (c.toInt() > 127 || c == '"' || c == '<' || c == '>' || c == '&' || c == '$' || c == '{' || c == '}') {
+            out.append("&#")
+            out.append(c.toInt())
+            out.append(';')
+        } else {
+            out.append(c)
+        }
+    }
+    return out.toString()
+}
+
+/**
+ * Used to display description text.
+ */
+fun formatTextasHTML(string: String, useParagraphs: Boolean = true): String {
+    if (string.isEmpty()) return string
+
+    val sb = StringBuilder()
+    if (useParagraphs) sb.append("<p>")
+    //match and replace empty lines
+    val replaceText = if (useParagraphs) "</p>\n<p>" else "<br>\n"
+    sb.append(htmlEscape(string.trim()).replace(Regex("\\s*\n\n\\s*"), replaceText))
+    if (useParagraphs) sb.append("</p>")
+    return sb.toString()
+}
+
+private val summaryRegex = Regex("\\.|\n\n") //match period or empty line
+
+/**
+ * Given a block of description text, return the first sentence.
+ */
+fun getDescSummaryText(string: String): String {
+    return if (string.isEmpty()) {
+        string
+    } else {
+        val s = string.trimStart() // remove any beginning empty lines/whitespace
+        val sb = StringBuilder(summaryRegex.split(s)[0])
+        if (sb[sb.length - 1] != '.') sb.append(".") // add period, if needed
+        formatTextasHTML(sb.toString())
+    }
+}
+
+/**
+ * Return the out file path for a given parser.
+ */
+fun getOutPath(parser: AbstractFileParser, outDir: Path): Path {
+    val pkgPath = parser.packageName.replace(".", File.separator)
+    val dirPath = "${outDir}${File.separator}${pkgPath}${File.separator}${parser.packageVersion}"
+    return Paths.get("${dirPath}${File.separator}${parser.name}.html")
+}
\ No newline at end of file
diff --git a/generateCpp.cpp b/generateCpp.cpp
index 7292732..fa2a3ca 100644
--- a/generateCpp.cpp
+++ b/generateCpp.cpp
@@ -18,9 +18,10 @@
 
 #include "Coordinator.h"
 #include "EnumType.h"
-#include "Interface.h"
 #include "HidlTypeAssertion.h"
+#include "Interface.h"
 #include "Method.h"
+#include "Reference.h"
 #include "ScalarType.h"
 #include "Scope.h"
 
@@ -33,38 +34,6 @@
 
 namespace android {
 
-status_t AST::generateCpp(const std::string &outputPath) const {
-    status_t err = generateCppHeaders(outputPath);
-
-    if (err == OK) {
-        err = generateCppSources(outputPath);
-    }
-
-    return err;
-}
-
-status_t AST::generateCppHeaders(const std::string &outputPath) const {
-    status_t err = generateInterfaceHeader(outputPath);
-
-    if (err == OK) {
-        err = generateStubHeader(outputPath);
-    }
-
-    if (err == OK) {
-        err = generateHwBinderHeader(outputPath);
-    }
-
-    if (err == OK) {
-        err = generateProxyHeader(outputPath);
-    }
-
-    if (err == OK) {
-        err = generatePassthroughHeader(outputPath);
-    }
-
-    return err;
-}
-
 void AST::getPackageComponents(
         std::vector<std::string> *components) const {
     mPackage.getPackageComponents(components);
@@ -175,173 +144,11 @@
         << "::android::sp<" << interfaceName << "> " << interfaceName << "::" << functionName << "("
         << "const std::string &serviceName, const bool getStub) ";
     out.block([&] {
-        out << "using ::android::hardware::defaultServiceManager;\n";
-        out << "using ::android::hardware::details::waitForHwService;\n";
-        out << "using ::android::hardware::getPassthroughServiceManager;\n";
-        out << "using ::android::hardware::Return;\n";
-        out << "using ::android::sp;\n";
-        out << "using Transport = ::android::hidl::manager::V1_0::IServiceManager::Transport;\n\n";
-
-        out << "sp<" << interfaceName << "> iface = nullptr;\n";
-
-        out.endl();
-
-        out << "const sp<::android::hidl::manager::V1_0::IServiceManager> sm"
-            << " = defaultServiceManager();\n";
-
-        out.sIf("sm == nullptr", [&] {
-            // hwbinder is not available on this device, so future tries
-            // would also be null. I can only return nullptr.
-            out << "ALOGE(\"getService: defaultServiceManager() is null\");\n"
-                << "return nullptr;\n";
-        }).endl().endl();
-
-        out << "Return<Transport> transportRet = sm->getTransport("
-            << interfaceName << "::descriptor, serviceName);\n\n";
-
-        out.sIf("!transportRet.isOk()", [&] {
-            out << "ALOGE(\"getService: defaultServiceManager()->getTransport returns %s\", "
-                << "transportRet.description().c_str());\n";
-            out << "return nullptr;\n";
-        }).endl();
-
-        out << "Transport transport = transportRet;\n";
-        out << "const bool vintfHwbinder = (transport == Transport::HWBINDER);\n"
-            << "const bool vintfPassthru = (transport == Transport::PASSTHROUGH);\n\n";
-
-        // This means that you must set TREBLE_TESTING_OVERRIDE when running a test such
-        // as hidl_test. Ideally these binaries set this value themselves. This allows
-        // test modules to dynamically add and unset services even though they are not
-        // declared in the device manifest. This prevents a problem where framework
-        // changes are accidentally made in a way that is not backwards compatible. For
-        // instance, consider the following situation for two devices developed in the
-        // same tree:
-        // A: serves @1.1::IFoo, declares @1.0::IFoo (incorrect)
-        // B: serves @1.0::IFoo, declares @1.0::IFoo (correct configuration)
-        // If development is done on device A, then framework code like: "V1_1::IFoo::
-        // getService()->doV1_0Api()" will work. However, this will unintentionally break
-        // the feature for devices like device B for which "V1_1::IFoo::getService()
-        // will return nullptr. In order to prevent problems like this, we only allow
-        // fetching an interface if it is declared in a VINTF manifest.
-        out << "#ifdef __ANDROID_TREBLE__\n\n"
-            << "#ifdef __ANDROID_DEBUGGABLE__\n"
-            << "const char* env = std::getenv(\"TREBLE_TESTING_OVERRIDE\");\n"
-            << "const bool trebleTestingOverride =  env && !strcmp(env, \"true\");\n"
-            << "const bool vintfLegacy = (transport == Transport::EMPTY) && trebleTestingOverride;\n"
-            << "#else // __ANDROID_TREBLE__ but not __ANDROID_DEBUGGABLE__\n"
-            << "const bool trebleTestingOverride = false;\n"
-            << "const bool vintfLegacy = false;\n"
-            << "#endif // __ANDROID_DEBUGGABLE__\n\n"
-            << "#else // not __ANDROID_TREBLE__\n"
-            << "const char* env = std::getenv(\"TREBLE_TESTING_OVERRIDE\");\n"
-            << "const bool trebleTestingOverride =  env && !strcmp(env, \"true\");\n"
-            << "const bool vintfLegacy = (transport == Transport::EMPTY);\n\n"
-            << "#endif // __ANDROID_TREBLE__\n\n";
-
-        // if (getStub) {
-        //     getPassthroughServiceManager()->get only once.
-        // } else {
-        //     if (vintfHwbinder) {
-        //         while (no alive service) {
-        //             if (have already tried to get service)
-        //                 waitForHwService
-        //             defaultServiceManager()->get
-        //         }
-        //     } else if (vintfLegacy) {
-        //         defaultServiceManager()->get only once.
-        //         getPassthroughServiceManager()->get only once.
-        //     } else if (vintfPassthru) {
-        //         getPassthroughServiceManager()->get only once.
-        //     }
-        // }
-
-        out.sFor("int tries = 0; !getStub && (vintfHwbinder || (vintfLegacy && tries == 0)); tries++", [&] {
-            if (!isTry) {
-                out.sIf("tries > 1", [&] {
-                    // sleep only after the first time we've called waitForHwService.
-                    out << "ALOGI(\"" << functionName << ": Will do try %d for %s/%s in 1s...\", tries, "
-                        << interfaceName << "::descriptor, serviceName.c_str());\n"
-                        << "sleep(1);\n";
-                }).endl();
-
-                out.sIf("vintfHwbinder && tries > 0", [&] {
-                    out << "waitForHwService("
-                        << interfaceName << "::descriptor, serviceName);\n";
-                }).endl();
-            }
-
-            out << "Return<sp<" << gIBaseFqName.cppName() << ">> ret = \n";
-            out.indent(2, [&] {
-                out << "sm->get(" << interfaceName << "::descriptor, serviceName);\n";
-            });
-
-            out.sIf("!ret.isOk()", [&] {
-                // hwservicemanager fails, may be security issue
-                out << "ALOGE(\"" << interfaceName << ": defaultServiceManager()->get returns %s\", "
-                    << "ret.description().c_str());\n"
-                    << "break;\n";
-            }).endl();
-
-            out << "sp<" << gIBaseFqName.cppName() << "> base = ret;\n";
-            out.sIf("base == nullptr", [&] {
-                // if tries > 0: race condition. hwservicemanager drops the service
-                // from waitForHwService to here
-                out.sIf("tries > 0", [&] {
-                    out << "ALOGW(\"" << interfaceName << ": found null hwbinder interface\");\n";
-                });
-                out << (isTry ? "break" : "continue")
-                    << ";\n";
-            }).endl();
-            out << "Return<sp<" << interfaceName
-                << ">> castRet = " << interfaceName << "::castFrom(base, true /* emitError */);\n";
-            out.sIf("!castRet.isOk()", [&] {
-                out.sIf("castRet.isDeadObject()", [&] {
-                    // service is dead (castFrom cannot call interfaceChain)
-                    out << "ALOGW(\"" << interfaceName << ": found dead hwbinder service\");\n"
-                        << (isTry ? "break" : "continue")
-                        << ";\n";
-                }).sElse([&] {
-                    out << "ALOGW(\"" << interfaceName << ": cannot call into hwbinder service: %s"
-                        << "; No permission? Check for selinux denials.\", "
-                        << "castRet.description().c_str());\n"
-                        << "break;\n";
-                }).endl();
-            }).endl();
-            out << "iface = castRet;\n";
-            out.sIf("iface == nullptr", [&] {
-                // returned service isn't of correct type; this is a bug
-                // to hwservicemanager or to the service itself (interfaceChain
-                // is not consistent).
-                out << "ALOGW(\"" << interfaceName << ": received incompatible service; bug in hwservicemanager?\");\n"
-                    << "break;\n";
-            }).endl();
-
-            out << "return iface;\n";
-        }).endl();
-
-        out.sIf("getStub || vintfPassthru || vintfLegacy", [&] {
-            out << "const sp<::android::hidl::manager::V1_0::IServiceManager> pm"
-                << " = getPassthroughServiceManager();\n";
-
-            out.sIf("pm != nullptr", [&] () {
-                out << "Return<sp<" << gIBaseFqName.cppName() << ">> ret = \n";
-                out.indent(2, [&] {
-                    out << "pm->get(" << interfaceName << "::descriptor" << ", serviceName);\n";
-                });
-                out.sIf("ret.isOk()", [&] {
-                    out << "sp<" << gIBaseFqName.cppName()
-                        << "> baseInterface = ret;\n";
-                    out.sIf("baseInterface != nullptr", [&]() {
-                        out << "iface = " << interfaceName << "::castFrom(baseInterface);\n";
-                        out.sIf("!getStub || trebleTestingOverride", [&] () {
-                            out << "iface = new " << fqName.getInterfacePassthroughName() << "(iface);\n";
-                        }).endl();
-                    }).endl();
-                }).endl();
-            }).endl();
-        }).endl();
-
-        out << "return iface;\n";
+        out << "return ::android::hardware::details::getServiceInternal<"
+            << fqName.getInterfaceProxyName()
+            << ">(serviceName, "
+            << (!isTry ? "true" : "false") // retry
+            << ", getStub);\n";
     }).endl().endl();
 }
 
@@ -397,25 +204,9 @@
     }).endl().endl();
 }
 
-status_t AST::generateInterfaceHeader(const std::string &outputPath) const {
+void AST::generateInterfaceHeader(Formatter& out) const {
     const Interface *iface = getInterface();
     std::string ifaceName = iface ? iface->localName() : "types";
-
-    std::string path = outputPath;
-    path.append(mCoordinator->convertPackageRootToPath(mPackage));
-    path.append(mCoordinator->getPackagePath(mPackage, true /* relative */));
-    path.append(ifaceName);
-    path.append(".h");
-
-    CHECK(Coordinator::MakeParentHierarchy(path));
-    FILE *file = fopen(path.c_str(), "w");
-
-    if (file == NULL) {
-        return -errno;
-    }
-
-    Formatter out(file);
-
     const std::string guard = makeHeaderGuard(ifaceName);
 
     out << "#ifndef " << guard << "\n";
@@ -467,13 +258,10 @@
 
         out.indent();
 
+        generateCppTag(out, "android::hardware::details::i_tag");
     }
 
-    status_t err = emitTypeDeclarations(out);
-
-    if (err != OK) {
-        return err;
-    }
+    emitTypeDeclarations(out);
 
     if (iface) {
         out << "virtual bool isRemote() const ";
@@ -488,7 +276,7 @@
             out << "\n";
 
             const bool returnsValue = !method->results().empty();
-            const TypedVar *elidedReturn = method->canElideCallback();
+            const NamedReference<Type>* elidedReturn = method->canElideCallback();
 
             if (elidedReturn == nullptr && returnsValue) {
                 out << "using "
@@ -500,6 +288,8 @@
 
             method->dumpAnnotations(out);
 
+            method->emitDocComment(out);
+
             if (elidedReturn) {
                 out << "virtual ::android::hardware::Return<";
                 out << elidedReturn->type().getCppResultType() << "> ";
@@ -548,37 +338,20 @@
         out << "};\n\n";
     }
 
-    err = mRootScope.emitGlobalTypeDeclarations(out);
-
-    if (err != OK) {
-        return err;
-    }
+    mRootScope.emitPackageTypeDeclarations(out);
 
     out << "\n";
     enterLeaveNamespace(out, false /* enter */);
 
-    out << "\n#endif  // " << guard << "\n";
+    mRootScope.emitGlobalTypeDeclarations(out);
 
-    return OK;
+    out << "\n#endif  // " << guard << "\n";
 }
 
-status_t AST::generateHwBinderHeader(const std::string &outputPath) const {
+void AST::generateHwBinderHeader(Formatter& out) const {
     const Interface *iface = getInterface();
     std::string klassName = iface ? iface->getHwName() : "hwtypes";
 
-    std::string path = outputPath;
-    path.append(mCoordinator->convertPackageRootToPath(mPackage));
-    path.append(mCoordinator->getPackagePath(mPackage, true /* relative */));
-    path.append(klassName + ".h");
-
-    FILE *file = fopen(path.c_str(), "w");
-
-    if (file == NULL) {
-        return -errno;
-    }
-
-    Formatter out(file);
-
     const std::string guard = makeHeaderGuard(klassName);
 
     out << "#ifndef " << guard << "\n";
@@ -607,25 +380,19 @@
 
     enterLeaveNamespace(out, true /* enter */);
 
-    status_t err = mRootScope.emitGlobalHwDeclarations(out);
-    if (err != OK) {
-        return err;
-    }
+    mRootScope.emitPackageHwDeclarations(out);
 
     enterLeaveNamespace(out, false /* enter */);
 
     out << "\n#endif  // " << guard << "\n";
-
-    return OK;
 }
 
-status_t AST::emitTypeDeclarations(Formatter &out) const {
+void AST::emitTypeDeclarations(Formatter& out) const {
     return mRootScope.emitTypeDeclarations(out);
 }
 
-static void wrapPassthroughArg(Formatter &out,
-        const TypedVar *arg, bool addPrefixToName,
-        std::function<void(void)> handleError) {
+static void wrapPassthroughArg(Formatter& out, const NamedReference<Type>* arg,
+                               bool addPrefixToName, std::function<void(void)> handleError) {
     if (!arg->type().isInterface()) {
         return;
     }
@@ -638,11 +405,9 @@
     out.sIf(name + " != nullptr && !" + name + "->isRemote()", [&] {
         out << wrappedName
             << " = "
-            << iface.fqName().cppName()
-            << "::castFrom(::android::hardware::details::wrapPassthrough<"
-            << iface.fqName().cppName()
-            << ">("
-            << name << "));\n";
+            << "::android::hardware::details::wrapPassthrough("
+            << name
+            << ");\n";
         out.sIf(wrappedName + " == nullptr", [&] {
             // Fatal error. Happens when the BsFoo class is not found in the binary
             // or any dynamic libraries.
@@ -653,8 +418,7 @@
     }).endl().endl();
 }
 
-status_t AST::generatePassthroughMethod(Formatter &out,
-                                        const Method *method) const {
+void AST::generatePassthroughMethod(Formatter& out, const Method* method) const {
     method->generateCppSignature(out);
 
     out << " {\n";
@@ -665,11 +429,11 @@
         method->cppImpl(IMPL_PASSTHROUGH, out);
         out.unindent();
         out << "}\n\n";
-        return OK;
+        return;
     }
 
     const bool returnsValue = !method->results().empty();
-    const TypedVar *elidedReturn = method->canElideCallback();
+    const NamedReference<Type>* elidedReturn = method->canElideCallback();
 
     if (returnsValue && elidedReturn == nullptr) {
         generateCheckNonNull(out, "_hidl_cb");
@@ -779,11 +543,9 @@
 
     out.unindent();
     out << "}\n";
-
-    return OK;
 }
 
-status_t AST::generateMethods(Formatter &out, MethodGenerator gen, bool includeParent) const {
+void AST::generateMethods(Formatter& out, const MethodGenerator& gen, bool includeParent) const {
     const Interface* iface = mRootScope.getInterface();
 
     const Interface *prevIterface = nullptr;
@@ -804,52 +566,32 @@
                 << " follow.\n";
             prevIterface = superInterface;
         }
-        status_t err = gen(method, superInterface);
-
-        if (err != OK) {
-            return err;
-        }
+        gen(method, superInterface);
     }
 
     out << "\n";
-
-    return OK;
 }
 
 void AST::generateTemplatizationLink(Formatter& out) const {
     out << "typedef " << mRootScope.getInterface()->localName() << " Pure;\n\n";
 }
 
-status_t AST::generateStubHeader(const std::string &outputPath) const {
-    if (!AST::isInterface()) {
-        // types.hal does not get a stub header.
-        return OK;
-    }
+void AST::generateCppTag(Formatter& out, const std::string& tag) const {
+    out << "typedef " << tag << " _hidl_tag;\n\n";
+}
+
+void AST::generateStubHeader(Formatter& out) const {
+    CHECK(AST::isInterface());
 
     const Interface* iface = mRootScope.getInterface();
     const std::string klassName = iface->getStubName();
-
-    std::string path = outputPath;
-    path.append(mCoordinator->convertPackageRootToPath(mPackage));
-    path.append(mCoordinator->getPackagePath(mPackage, true /* relative */));
-    path.append(klassName);
-    path.append(".h");
-
-    CHECK(Coordinator::MakeParentHierarchy(path));
-    FILE *file = fopen(path.c_str(), "w");
-
-    if (file == NULL) {
-        return -errno;
-    }
-
-    Formatter out(file);
-
     const std::string guard = makeHeaderGuard(klassName);
 
     out << "#ifndef " << guard << "\n";
     out << "#define " << guard << "\n\n";
 
     generateCppPackageInclude(out, mPackage, iface->getHwName());
+
     out << "\n";
 
     enterLeaveNamespace(out, true /* enter */);
@@ -891,41 +633,40 @@
 
     out.endl();
     generateTemplatizationLink(out);
+    generateCppTag(out, "android::hardware::details::bnhw_tag");
 
-    out << "::android::sp<" << iface->localName() << "> getImpl() { return _hidl_mImpl; };\n";
+    out << "::android::sp<" << iface->localName() << "> getImpl() { return _hidl_mImpl; }\n";
 
-    status_t err = generateMethods(out, [&](const Method *method, const Interface *) {
-        if (method->isHidlReserved() && method->overridesCppImpl(IMPL_PROXY)) {
-            return OK;
-        }
+    generateMethods(out,
+                    [&](const Method* method, const Interface*) {
+                        if (method->isHidlReserved() && method->overridesCppImpl(IMPL_PROXY)) {
+                            return;
+                        }
 
-        out << "static ::android::status_t _hidl_" << method->name() << "(\n";
+                        out << "static ::android::status_t _hidl_" << method->name() << "(\n";
 
-        out.indent(2, [&] {
-            out << "::android::hidl::base::V1_0::BnHwBase* _hidl_this,\n"
-                << "const ::android::hardware::Parcel &_hidl_data,\n"
-                << "::android::hardware::Parcel *_hidl_reply,\n"
-                << "TransactCallback _hidl_cb);\n";
-        }).endl().endl();
-
-        return OK;
-    }, false /* include parents */);
-
-    if (err != OK) {
-        return err;
-    }
+                        out.indent(2,
+                                   [&] {
+                                       out << "::android::hidl::base::V1_0::BnHwBase* _hidl_this,\n"
+                                           << "const ::android::hardware::Parcel &_hidl_data,\n"
+                                           << "::android::hardware::Parcel *_hidl_reply,\n"
+                                           << "TransactCallback _hidl_cb);\n";
+                                   })
+                            .endl()
+                            .endl();
+                    },
+                    false /* include parents */);
 
     out.unindent();
     out << "private:\n";
     out.indent();
 
-
-    err = generateMethods(out, [&](const Method *method, const Interface *iface) {
+    generateMethods(out, [&](const Method* method, const Interface* iface) {
         if (!method->isHidlReserved() || !method->overridesCppImpl(IMPL_STUB_IMPL)) {
-            return OK;
+            return;
         }
         const bool returnsValue = !method->results().empty();
-        const TypedVar *elidedReturn = method->canElideCallback();
+        const NamedReference<Type>* elidedReturn = method->canElideCallback();
 
         if (elidedReturn == nullptr && returnsValue) {
             out << "using " << method->name() << "_cb = "
@@ -934,11 +675,7 @@
         }
         method->generateCppSignature(out);
         out << ";\n";
-        return OK;
     });
-    if (err != OK) {
-        return err;
-    }
 
     out << "::android::sp<" << iface->localName() << "> _hidl_mImpl;\n";
     out.unindent();
@@ -947,34 +684,16 @@
     enterLeaveNamespace(out, false /* enter */);
 
     out << "\n#endif  // " << guard << "\n";
-
-    return OK;
 }
 
-status_t AST::generateProxyHeader(const std::string &outputPath) const {
+void AST::generateProxyHeader(Formatter& out) const {
     if (!AST::isInterface()) {
         // types.hal does not get a proxy header.
-        return OK;
+        return;
     }
 
     const Interface* iface = mRootScope.getInterface();
     const std::string proxyName = iface->getProxyName();
-
-    std::string path = outputPath;
-    path.append(mCoordinator->convertPackageRootToPath(mPackage));
-    path.append(mCoordinator->getPackagePath(mPackage, true /* relative */));
-    path.append(proxyName);
-    path.append(".h");
-
-    CHECK(Coordinator::MakeParentHierarchy(path));
-    FILE *file = fopen(path.c_str(), "w");
-
-    if (file == NULL) {
-        return -errno;
-    }
-
-    Formatter out(file);
-
     const std::string guard = makeHeaderGuard(proxyName);
 
     out << "#ifndef " << guard << "\n";
@@ -1006,44 +725,36 @@
         << "\n\n";
 
     generateTemplatizationLink(out);
+    generateCppTag(out, "android::hardware::details::bphw_tag");
 
     out << "virtual bool isRemote() const override { return true; }\n\n";
 
-    status_t err = generateMethods(out, [&](const Method *method, const Interface *) {
-        if (method->isHidlReserved() && method->overridesCppImpl(IMPL_PROXY)) {
-            return OK;
-        }
+    generateMethods(
+        out,
+        [&](const Method* method, const Interface*) {
+            if (method->isHidlReserved() && method->overridesCppImpl(IMPL_PROXY)) {
+                return;
+            }
 
-        out << "static ";
-        method->generateCppReturnType(out);
-        out << " _hidl_"
-            << method->name()
-            << "("
-            << "::android::hardware::IInterface* _hidl_this, "
-            << "::android::hardware::details::HidlInstrumentor *_hidl_this_instrumentor";
+            out << "static ";
+            method->generateCppReturnType(out);
+            out << " _hidl_" << method->name() << "("
+                << "::android::hardware::IInterface* _hidl_this, "
+                << "::android::hardware::details::HidlInstrumentor *_hidl_this_instrumentor";
 
-        if (!method->hasEmptyCppArgSignature()) {
-            out << ", ";
-        }
-        method->emitCppArgSignature(out);
-        out << ");\n";
-        return OK;
-    }, false /* include parents */);
+            if (!method->hasEmptyCppArgSignature()) {
+                out << ", ";
+            }
+            method->emitCppArgSignature(out);
+            out << ");\n";
+        },
+        false /* include parents */);
 
-    if (err != OK) {
-        return err;
-    }
-
-    err = generateMethods(out, [&](const Method *method, const Interface *) {
+    generateMethods(out, [&](const Method* method, const Interface*) {
         method->generateCppSignature(out);
         out << " override;\n";
-        return OK;
     });
 
-    if (err != OK) {
-        return err;
-    }
-
     out.unindent();
     out << "private:\n";
     out.indent();
@@ -1056,33 +767,13 @@
     enterLeaveNamespace(out, false /* enter */);
 
     out << "\n#endif  // " << guard << "\n";
-
-    return OK;
 }
 
-status_t AST::generateCppSources(const std::string &outputPath) const {
+void AST::generateCppSource(Formatter& out) const {
     std::string baseName = getBaseName();
     const Interface *iface = getInterface();
 
-    std::string path = outputPath;
-    path.append(mCoordinator->convertPackageRootToPath(mPackage));
-    path.append(mCoordinator->getPackagePath(mPackage, true /* relative */));
-    path.append(baseName);
-
-    if (baseName != "types") {
-        path.append("All");
-    }
-
-    path.append(".cpp");
-
-    CHECK(Coordinator::MakeParentHierarchy(path));
-    FILE *file = fopen(path.c_str(), "w");
-
-    if (file == NULL) {
-        return -errno;
-    }
-
-    Formatter out(file);
+    const std::string klassName = baseName + (baseName == "types" ? "" : "All");
 
     out << "#define LOG_TAG \""
         << mPackage.string() << "::" << baseName
@@ -1116,9 +807,9 @@
     enterLeaveNamespace(out, true /* enter */);
     out << "\n";
 
-    status_t err = generateTypeSource(out, iface ? iface->localName() : "");
+    generateTypeSource(out, iface ? iface->localName() : "");
 
-    if (err == OK && iface) {
+    if (iface) {
         const Interface* iface = mRootScope.getInterface();
 
         // need to be put here, generateStubSource is using this.
@@ -1127,10 +818,10 @@
             << "::descriptor(\""
             << iface->fqName().string()
             << "\");\n\n";
-        out << "__attribute__((constructor))";
+        out << "__attribute__((constructor)) ";
         out << "static void static_constructor() {\n";
         out.indent([&] {
-            out << "::android::hardware::details::gBnConstructorMap.set("
+            out << "::android::hardware::details::getBnConstructorMap().set("
                 << iface->localName()
                 << "::descriptor,\n";
             out.indent(2, [&] {
@@ -1144,7 +835,7 @@
                 });
                 out << "});\n";
             });
-            out << "::android::hardware::details::gBsConstructorMap.set("
+            out << "::android::hardware::details::getBsConstructorMap().set("
                 << iface->localName()
                 << "::descriptor,\n";
             out.indent(2, [&] {
@@ -1165,32 +856,19 @@
         out << "__attribute__((destructor))";
         out << "static void static_destructor() {\n";
         out.indent([&] {
-            out << "::android::hardware::details::gBnConstructorMap.erase("
+            out << "::android::hardware::details::getBnConstructorMap().erase("
                 << iface->localName()
                 << "::descriptor);\n";
-            out << "::android::hardware::details::gBsConstructorMap.erase("
+            out << "::android::hardware::details::getBsConstructorMap().erase("
                 << iface->localName()
                 << "::descriptor);\n";
         });
         out << "};\n\n";
 
-        err = generateInterfaceSource(out);
-    }
-
-    if (err == OK && iface) {
-        err = generateProxySource(out, iface->fqName());
-    }
-
-    if (err == OK && iface) {
-        err = generateStubSource(out, iface);
-    }
-
-    if (err == OK && iface) {
-        err = generatePassthroughSource(out);
-    }
-
-    if (err == OK && iface) {
-        const Interface* iface = mRootScope.getInterface();
+        generateInterfaceSource(out);
+        generateProxySource(out, iface->fqName());
+        generateStubSource(out, iface);
+        generatePassthroughSource(out);
 
         if (isIBase()) {
             out << "// skipped getService, registerAsService, registerForNotifications\n";
@@ -1206,8 +884,6 @@
     out << "\n";
 
     enterLeaveNamespace(out, false /* enter */);
-
-    return err;
 }
 
 void AST::generateCheckNonNull(Formatter &out, const std::string &nonNull) {
@@ -1220,15 +896,12 @@
     }).endl().endl();
 }
 
-status_t AST::generateTypeSource(
-        Formatter &out, const std::string &ifaceName) const {
-    return mRootScope.emitTypeDefinitions(out, ifaceName);
+void AST::generateTypeSource(Formatter& out, const std::string& ifaceName) const {
+    mRootScope.emitTypeDefinitions(out, ifaceName);
 }
 
-void AST::declareCppReaderLocals(
-        Formatter &out,
-        const std::vector<TypedVar *> &args,
-        bool forResults) const {
+void AST::declareCppReaderLocals(Formatter& out, const std::vector<NamedReference<Type>*>& args,
+                                 bool forResults) const {
     if (args.empty()) {
         return;
     }
@@ -1245,14 +918,9 @@
     out << "\n";
 }
 
-void AST::emitCppReaderWriter(
-        Formatter &out,
-        const std::string &parcelObj,
-        bool parcelObjIsPointer,
-        const TypedVar *arg,
-        bool isReader,
-        Type::ErrorMode mode,
-        bool addPrefixToName) const {
+void AST::emitCppReaderWriter(Formatter& out, const std::string& parcelObj, bool parcelObjIsPointer,
+                              const NamedReference<Type>* arg, bool isReader, Type::ErrorMode mode,
+                              bool addPrefixToName) const {
     const Type &type = arg->type();
 
     type.emitReaderWriter(
@@ -1264,14 +932,10 @@
             mode);
 }
 
-void AST::emitCppResolveReferences(
-        Formatter &out,
-        const std::string &parcelObj,
-        bool parcelObjIsPointer,
-        const TypedVar *arg,
-        bool isReader,
-        Type::ErrorMode mode,
-        bool addPrefixToName) const {
+void AST::emitCppResolveReferences(Formatter& out, const std::string& parcelObj,
+                                   bool parcelObjIsPointer, const NamedReference<Type>* arg,
+                                   bool isReader, Type::ErrorMode mode,
+                                   bool addPrefixToName) const {
     const Type &type = arg->type();
     if(type.needsResolveReferences()) {
         type.emitResolveReferences(
@@ -1285,10 +949,8 @@
     }
 }
 
-status_t AST::generateProxyMethodSource(Formatter &out,
-                                        const std::string &klassName,
-                                        const Method *method,
-                                        const Interface *superInterface) const {
+void AST::generateProxyMethodSource(Formatter& out, const std::string& klassName,
+                                    const Method* method, const Interface* superInterface) const {
     method->generateCppSignature(out,
                                  klassName,
                                  true /* specify namespaces */);
@@ -1297,14 +959,12 @@
         out.block([&] {
             method->cppImpl(IMPL_PROXY, out);
         }).endl().endl();
-        return OK;
+        return;
     }
 
-    status_t err = OK;
-
     out.block([&] {
         const bool returnsValue = !method->results().empty();
-        const TypedVar *elidedReturn = method->canElideCallback();
+        const NamedReference<Type>* elidedReturn = method->canElideCallback();
 
         method->generateCppReturnType(out);
 
@@ -1335,15 +995,12 @@
 
         out << "return _hidl_out;\n";
     }).endl().endl();
-
-    return err;
 }
 
-status_t AST::generateStaticProxyMethodSource(Formatter &out,
-                                              const std::string &klassName,
-                                              const Method *method) const {
+void AST::generateStaticProxyMethodSource(Formatter& out, const std::string& klassName,
+                                          const Method* method) const {
     if (method->isHidlReserved() && method->overridesCppImpl(IMPL_PROXY)) {
-        return OK;
+        return;
     }
 
     method->generateCppReturnType(out);
@@ -1372,7 +1029,7 @@
     out << "#endif // __ANDROID_DEBUGGABLE__\n";
 
     const bool returnsValue = !method->results().empty();
-    const TypedVar *elidedReturn = method->canElideCallback();
+    const NamedReference<Type>* elidedReturn = method->canElideCallback();
     if (returnsValue && elidedReturn == nullptr) {
         generateCheckNonNull(out, "_hidl_cb");
     }
@@ -1434,7 +1091,7 @@
         << " */, _hidl_data, &_hidl_reply";
 
     if (method->isOneway()) {
-        out << ", ::android::hardware::IBinder::FLAG_ONEWAY";
+        out << ", " << Interface::FLAG_ONEWAY << " /* oneway */";
     }
     out << ");\n";
 
@@ -1513,11 +1170,9 @@
 
     out.unindent();
     out << "}\n\n";
-    return OK;
 }
 
-status_t AST::generateProxySource(
-        Formatter &out, const FQName &fqName) const {
+void AST::generateProxySource(Formatter& out, const FQName& fqName) const {
     const std::string klassName = fqName.getInterfaceProxyName();
 
     out << klassName
@@ -1542,24 +1197,18 @@
     out.unindent();
     out << "}\n\n";
 
-    status_t err = generateMethods(out, [&](const Method *method, const Interface *) {
-        return generateStaticProxyMethodSource(out, klassName, method);
-    }, false /* include parents */);
+    generateMethods(out,
+                    [&](const Method* method, const Interface*) {
+                        generateStaticProxyMethodSource(out, klassName, method);
+                    },
+                    false /* include parents */);
 
-    if (err != OK) {
-        return err;
-    }
-
-    err = generateMethods(out, [&](const Method *method, const Interface *superInterface) {
-        return generateProxyMethodSource(out, klassName, method, superInterface);
+    generateMethods(out, [&](const Method* method, const Interface* superInterface) {
+        generateProxyMethodSource(out, klassName, method, superInterface);
     });
-
-    return err;
 }
 
-status_t AST::generateStubSource(
-        Formatter &out,
-        const Interface *iface) const {
+void AST::generateStubSource(Formatter& out, const Interface* iface) const {
     const std::string interfaceName = iface->localName();
     const std::string klassName = iface->getStubName();
 
@@ -1625,24 +1274,22 @@
         out << "::android::hardware::details::gBnMap.eraseIfEqual(_hidl_mImpl.get(), this);\n";
     }).endl().endl();
 
-    status_t err = generateMethods(out, [&](const Method *method, const Interface *) {
-        return generateStaticStubMethodSource(out, klassName, method);
-    }, false /* include parents */);
+    generateMethods(out,
+                    [&](const Method* method, const Interface*) {
+                        return generateStaticStubMethodSource(out, iface->fqName(), method);
+                    },
+                    false /* include parents */);
 
-    err = generateMethods(out, [&](const Method *method, const Interface *) {
+    generateMethods(out, [&](const Method* method, const Interface*) {
         if (!method->isHidlReserved() || !method->overridesCppImpl(IMPL_STUB_IMPL)) {
-            return OK;
+            return;
         }
         method->generateCppSignature(out, iface->getStubName());
         out << " ";
         out.block([&] {
             method->cppImpl(IMPL_STUB_IMPL, out);
         }).endl();
-        return OK;
     });
-    if (err != OK) {
-        return err;
-    }
 
     out << "::android::status_t " << klassName << "::onTransact(\n";
 
@@ -1665,6 +1312,9 @@
         const Method *method = tuple.method();
         const Interface *superInterface = tuple.interface();
 
+        if (!isIBase() && method->isHidlReserved()) {
+            continue;
+        }
         out << "case "
             << method->getSerialId()
             << " /* "
@@ -1673,15 +1323,12 @@
 
         out.indent();
 
-        out << "bool _hidl_is_oneway = _hidl_flags & ::android::hardware::IBinder::FLAG_ONEWAY;\n";
+        out << "bool _hidl_is_oneway = _hidl_flags & " << Interface::FLAG_ONEWAY
+            << " /* oneway */;\n";
         out << "if (_hidl_is_oneway != " << (method->isOneway() ? "true" : "false") << ") ";
         out.block([&] { out << "return ::android::UNKNOWN_ERROR;\n"; }).endl().endl();
 
-        status_t err = generateStubSourceForMethod(out, method, superInterface);
-
-        if (err != OK) {
-            return err;
-        }
+        generateStubSourceForMethod(out, method, superInterface);
 
         out.unindent();
         out << "}\n\n";
@@ -1726,19 +1373,14 @@
 
     out.unindent();
     out << "}\n\n";
-
-    return OK;
 }
 
-status_t AST::generateStubSourceForMethod(
-        Formatter &out,
-        const Method *method,
-        const Interface* superInterface) const {
-
+void AST::generateStubSourceForMethod(Formatter& out, const Method* method,
+                                      const Interface* superInterface) const {
     if (method->isHidlReserved() && method->overridesCppImpl(IMPL_STUB)) {
         method->cppImpl(IMPL_STUB, out);
         out << "break;\n";
-        return OK;
+        return;
     }
 
     out << "_hidl_err = "
@@ -1749,17 +1391,16 @@
         << method->name()
         << "(this, _hidl_data, _hidl_reply, _hidl_cb);\n";
     out << "break;\n";
-
-    return OK;
 }
 
-status_t AST::generateStaticStubMethodSource(Formatter &out,
-                                             const std::string &klassName,
-                                             const Method *method) const {
+void AST::generateStaticStubMethodSource(Formatter& out, const FQName& fqName,
+                                         const Method* method) const {
     if (method->isHidlReserved() && method->overridesCppImpl(IMPL_STUB)) {
-        return OK;
+        return;
     }
 
+    const std::string& klassName = fqName.getInterfaceStubName();
+
     out << "::android::status_t " << klassName << "::_hidl_" << method->name() << "(\n";
 
     out.indent();
@@ -1821,14 +1462,14 @@
             method);
 
     const bool returnsValue = !method->results().empty();
-    const TypedVar *elidedReturn = method->canElideCallback();
+    const NamedReference<Type>* elidedReturn = method->canElideCallback();
 
     std::string callee;
 
     if (method->isHidlReserved() && method->overridesCppImpl(IMPL_STUB_IMPL)) {
         callee = "_hidl_this";
     } else {
-        callee = "static_cast<" + klassName + "*>(_hidl_this)->_hidl_mImpl";
+        callee = "static_cast<" + fqName.getInterfaceName() + "*>(_hidl_this->getImpl().get())";
     }
 
     if (elidedReturn != nullptr) {
@@ -1973,14 +1614,12 @@
     out << "return _hidl_err;\n";
     out.unindent();
     out << "}\n\n";
-
-    return OK;
 }
 
-status_t AST::generatePassthroughHeader(const std::string &outputPath) const {
+void AST::generatePassthroughHeader(Formatter& out) const {
     if (!AST::isInterface()) {
         // types.hal does not get a stub header.
-        return OK;
+        return;
     }
 
     const Interface* iface = mRootScope.getInterface();
@@ -1990,21 +1629,6 @@
 
     bool supportOneway = iface->hasOnewayMethods();
 
-    std::string path = outputPath;
-    path.append(mCoordinator->convertPackageRootToPath(mPackage));
-    path.append(mCoordinator->getPackagePath(mPackage, true /* relative */));
-    path.append(klassName);
-    path.append(".h");
-
-    CHECK(Coordinator::MakeParentHierarchy(path));
-    FILE *file = fopen(path.c_str(), "w");
-
-    if (file == NULL) {
-        return -errno;
-    }
-
-    Formatter out(file);
-
     const std::string guard = makeHeaderGuard(klassName);
 
     out << "#ifndef " << guard << "\n";
@@ -2043,15 +1667,12 @@
 
     out.endl();
     generateTemplatizationLink(out);
+    generateCppTag(out, "android::hardware::details::bs_tag");
 
-    status_t err = generateMethods(out, [&](const Method *method, const Interface *) {
-        return generatePassthroughMethod(out, method);
+    generateMethods(out, [&](const Method* method, const Interface*) {
+        generatePassthroughMethod(out, method);
     });
 
-    if (err != OK) {
-        return err;
-    }
-
     out.unindent();
     out << "private:\n";
     out.indent();
@@ -2073,17 +1694,15 @@
     enterLeaveNamespace(out, false /* enter */);
 
     out << "\n#endif  // " << guard << "\n";
-
-    return OK;
 }
 
-status_t AST::generateInterfaceSource(Formatter &out) const {
+void AST::generateInterfaceSource(Formatter& out) const {
     const Interface* iface = mRootScope.getInterface();
 
     // generate castFrom functions
     std::string childTypeResult = iface->getCppResultType();
 
-    status_t err = generateMethods(out, [&](const Method *method, const Interface *) {
+    generateMethods(out, [&](const Method* method, const Interface*) {
         bool reserved = method->isHidlReserved();
 
         if (!reserved) {
@@ -2098,11 +1717,8 @@
 
         out << "\n";
 
-        return OK;
+        return;
     });
-    if (err != OK) {
-        return err;
-    }
 
     for (const Interface *superType : iface->typeChain()) {
         out << "// static \n::android::hardware::Return<"
@@ -2134,11 +1750,9 @@
         out.unindent();
         out << "}\n\n";
     }
-
-    return OK;
 }
 
-status_t AST::generatePassthroughSource(Formatter &out) const {
+void AST::generatePassthroughSource(Formatter& out) const {
     const Interface* iface = mRootScope.getInterface();
 
     const std::string klassName = iface->getPassthroughName();
@@ -2185,8 +1799,6 @@
 
 
     }
-
-    return OK;
 }
 
 void AST::generateCppAtraceCall(Formatter &out,
@@ -2222,7 +1834,7 @@
         }
         default:
         {
-            LOG(FATAL) << "Unsupported instrumentation event: " << event;
+            CHECK(false) << "Unsupported instrumentation event: " << event;
         }
     }
 }
@@ -2304,7 +1916,7 @@
         }
         default:
         {
-            LOG(FATAL) << "Unsupported instrumentation event: " << event;
+            CHECK(false) << "Unsupported instrumentation event: " << event;
         }
     }
 
diff --git a/generateCppAdapter.cpp b/generateCppAdapter.cpp
new file mode 100644
index 0000000..1fbfb57
--- /dev/null
+++ b/generateCppAdapter.cpp
@@ -0,0 +1,193 @@
+/*
+ * Copyright (C) 2017 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 "AST.h"
+
+#include "Coordinator.h"
+#include "EnumType.h"
+#include "HidlTypeAssertion.h"
+#include "Interface.h"
+#include "Method.h"
+#include "Reference.h"
+#include "ScalarType.h"
+#include "Scope.h"
+
+#include <android-base/logging.h>
+#include <hidl-util/Formatter.h>
+#include <hidl-util/StringHelper.h>
+#include <algorithm>
+#include <string>
+#include <vector>
+
+namespace android {
+
+void AST::generateCppAdapterHeader(Formatter& out) const {
+    const std::string klassName = AST::isInterface() ? getInterface()->getAdapterName() : "Atypes";
+    const std::string guard = makeHeaderGuard(klassName, true /* indicateGenerated */);
+
+    out << "#ifndef " << guard << "\n";
+    out << "#define " << guard << "\n\n";
+
+    if (AST::isInterface()) {
+        generateCppPackageInclude(out, mPackage, getInterface()->localName());
+
+        enterLeaveNamespace(out, true /* enter */);
+        out.endl();
+
+        const std::string mockName = getInterface()->fqName().cppName();
+
+        out << "class " << klassName << " : public " << mockName << " ";
+        out.block([&] {
+            out << "public:\n";
+            out << "typedef " << mockName << " Pure;\n";
+
+            out << klassName << "(::android::sp<" << mockName << "> impl);\n";
+
+            generateMethods(out, [&](const Method* method, const Interface* /* interface */) {
+                if (method->isHidlReserved()) {
+                    return;
+                }
+
+                out << "virtual ";
+                method->generateCppSignature(out);
+                out << " override;\n";
+            });
+            out << "private:\n";
+            out << "::android::sp<" << mockName << "> mImpl;\n";
+
+        }) << ";\n\n";
+
+        enterLeaveNamespace(out, false /* enter */);
+    } else {
+        out << "// no adapters for types.hal\n";
+    }
+
+    out << "#endif // " << guard << "\n";
+}
+
+void AST::generateCppAdapterSource(Formatter& out) const {
+    const std::string klassName = AST::isInterface() ? getInterface()->getAdapterName() : "Atypes";
+
+    generateCppPackageInclude(out, mPackage, klassName);
+
+    if (AST::isInterface()) {
+        out << "#include <hidladapter/HidlBinderAdapter.h>\n";
+        generateCppPackageInclude(out, mPackage, getInterface()->localName());
+
+        std::set<FQName> allImportedNames;
+        getAllImportedNames(&allImportedNames);
+        for (const auto& item : allImportedNames) {
+            if (item.name() == "types") {
+                continue;
+            }
+            generateCppPackageInclude(out, item, item.getInterfaceAdapterName());
+        }
+
+        out.endl();
+
+        enterLeaveNamespace(out, true /* enter */);
+        out.endl();
+
+        const std::string mockName = getInterface()->fqName().cppName();
+
+        out << klassName << "::" << klassName << "(::android::sp<" << mockName
+            << "> impl) : mImpl(impl) {}";
+
+        generateMethods(out, [&](const Method* method, const Interface* /* interface */) {
+            generateAdapterMethod(out, method);
+        });
+
+        enterLeaveNamespace(out, false /* enter */);
+        out.endl();
+    } else {
+        out << "// no adapters for types.hal\n";
+    }
+}
+
+void AST::generateAdapterMethod(Formatter& out, const Method* method) const {
+    if (method->isHidlReserved()) {
+        return;
+    }
+
+    const auto adapt = [](Formatter& out, const std::string& var, const Type* type) {
+        if (!type->isInterface()) {
+            out << var;
+            return;
+        }
+
+        // TODO(b/66900959): if we are creating the adapter for a 1.1 IFoo
+        // and we are using a method that takes/returns a 1.0 Callback, but
+        // there exists a 1.1 Callback (or other subclass that is depended
+        // on by this module), then wrap with the adapter subclass adapter
+        // IFF that callback is a subclass. However, if the callback
+        // is 1.0 ICallback, then wrap with a 1.0 adapter.
+
+        const Interface* interface = static_cast<const Interface*>(type);
+        out << "static_cast<::android::sp<" << interface->fqName().cppName() << ">>("
+            << interface->fqName().cppName() << "::castFrom("
+            << "::android::hardware::details::adaptWithDefault("
+            << "static_cast<::android::sp<" << interface->fqName().cppName() << ">>(" << var
+            << "), [&] { return new " << interface->fqName().getInterfaceAdapterFqName().cppName()
+            << "(" << var << "); })))";
+    };
+
+    const std::string klassName = getInterface()->getAdapterName();
+
+    method->generateCppSignature(out, klassName);
+    out.block([&] {
+         bool hasCallback = !method->canElideCallback() && !method->results().empty();
+
+         if (hasCallback) {
+             out << method->name() << "_cb _hidl_cb_wrapped = [&](";
+             method->emitCppResultSignature(out);
+             out << ") ";
+             out.block([&] {
+                 out << "return _hidl_cb(\n";
+                 out.indent([&]() {
+                     out.join(method->results().begin(), method->results().end(), ",\n",
+                              [&](auto arg) { adapt(out, arg->name(), arg->get()); });
+                 });
+                 out << ");\n";
+             });
+             out << ";\n";
+         }
+
+         out << "auto _hidl_out = mImpl->" << method->name() << "(\n";
+         out.indent([&]() {
+             out.join(method->args().begin(), method->args().end(), ",\n",
+                      [&](auto arg) { adapt(out, arg->name(), arg->get()); });
+             if (hasCallback) {
+                 if (!method->args().empty()) {
+                     out << ",\n";
+                 }
+                 out << "_hidl_cb_wrapped";
+             }
+         });
+         out << ");\n";
+
+         const auto elidedCallback = method->canElideCallback();
+         if (elidedCallback) {
+             out.sIf("!_hidl_out.isOkUnchecked()", [&] { out << "return _hidl_out;\n"; });
+             out << "return ";
+             adapt(out, "_hidl_out", elidedCallback->get());
+             out << ";\n";
+         } else {
+             out << "return _hidl_out;\n";
+         }
+     }).endl();
+}
+
+}  // namespace android
diff --git a/generateCppImpl.cpp b/generateCppImpl.cpp
index ae95590..18fac6b 100644
--- a/generateCppImpl.cpp
+++ b/generateCppImpl.cpp
@@ -20,6 +20,7 @@
 #include "EnumType.h"
 #include "Interface.h"
 #include "Method.h"
+#include "Reference.h"
 #include "ScalarType.h"
 #include "Scope.h"
 
@@ -32,27 +33,15 @@
 
 namespace android {
 
-status_t AST::generateCppImpl(const std::string &outputPath) const {
-    status_t err = generateStubImplHeader(outputPath);
-
-    if (err == OK) {
-        err = generateStubImplSource(outputPath);
-    }
-
-    return err;
-}
-
 void AST::generateFetchSymbol(Formatter &out, const std::string& ifaceName) const {
     out << "HIDL_FETCH_" << ifaceName;
 }
 
-status_t AST::generateStubImplMethod(Formatter &out,
-                                     const std::string &className,
-                                     const Method *method) const {
-
+void AST::generateStubImplMethod(Formatter& out, const std::string& className,
+                                 const Method* method) const {
     // ignore HIDL reserved methods -- implemented in IFoo already.
     if (method->isHidlReserved()) {
-        return OK;
+        return;
     }
 
     method->generateCppSignature(out, className, false /* specifyNamespaces */);
@@ -62,7 +51,7 @@
     out.indent();
     out << "// TODO implement\n";
 
-    const TypedVar *elidedReturn = method->canElideCallback();
+    const NamedReference<Type>* elidedReturn = method->canElideCallback();
 
     if (elidedReturn == nullptr) {
         out << "return Void();\n";
@@ -76,31 +65,18 @@
 
     out << "}\n\n";
 
-    return OK;
+    return;
 }
 
-status_t AST::generateStubImplHeader(const std::string &outputPath) const {
+void AST::generateCppImplHeader(Formatter& out) const {
     if (!AST::isInterface()) {
         // types.hal does not get a stub header.
-        return OK;
+        return;
     }
 
     const Interface* iface = mRootScope.getInterface();
     const std::string baseName = iface->getBaseName();
 
-    std::string path = outputPath;
-    path.append(baseName);
-    path.append(".h");
-
-    CHECK(Coordinator::MakeParentHierarchy(path));
-    FILE *file = fopen(path.c_str(), "w");
-
-    if (file == NULL) {
-        return -errno;
-    }
-
-    Formatter out(file);
-
     const std::string guard = makeHeaderGuard(baseName, false /* indicateGenerated */);
 
     out << "#ifndef " << guard << "\n";
@@ -132,21 +108,16 @@
 
     out.indent();
 
-    status_t err = generateMethods(out, [&](const Method *method, const Interface *) {
+    generateMethods(out, [&](const Method* method, const Interface*) {
         // ignore HIDL reserved methods -- implemented in IFoo already.
         if (method->isHidlReserved()) {
-            return OK;
+            return;
         }
         method->generateCppSignature(out, "" /* className */,
                 false /* specifyNamespaces */);
         out << " override;\n";
-        return OK;
     });
 
-    if (err != OK) {
-        return err;
-    }
-
     out.unindent();
 
     out << "};\n\n";
@@ -162,45 +133,26 @@
     enterLeaveNamespace(out, false /* leave */);
 
     out << "\n#endif  // " << guard << "\n";
-
-    return OK;
 }
 
-status_t AST::generateStubImplSource(const std::string &outputPath) const {
+void AST::generateCppImplSource(Formatter& out) const {
     if (!AST::isInterface()) {
         // types.hal does not get a stub header.
-        return OK;
+        return;
     }
 
     const Interface* iface = mRootScope.getInterface();
     const std::string baseName = iface->getBaseName();
 
-    std::string path = outputPath;
-    path.append(baseName);
-    path.append(".cpp");
-
-    CHECK(Coordinator::MakeParentHierarchy(path));
-    FILE *file = fopen(path.c_str(), "w");
-
-    if (file == NULL) {
-        return -errno;
-    }
-
-    Formatter out(file);
-
     out << "#include \"" << baseName << ".h\"\n\n";
 
     enterLeaveNamespace(out, true /* enter */);
     out << "namespace implementation {\n\n";
 
-    status_t err = generateMethods(out, [&](const Method *method, const Interface *) {
-        return generateStubImplMethod(out, baseName, method);
+    generateMethods(out, [&](const Method* method, const Interface*) {
+        generateStubImplMethod(out, baseName, method);
     });
 
-    if (err != OK) {
-        return err;
-    }
-
     out.setLinePrefix("//");
     out << iface->localName()
         << "* ";
@@ -214,8 +166,6 @@
 
     out << "}  // namespace implementation\n";
     enterLeaveNamespace(out, false /* leave */);
-
-    return OK;
 }
 
 }  // namespace android
diff --git a/generateJava.cpp b/generateJava.cpp
index f463b7f..bdbe25a 100644
--- a/generateJava.cpp
+++ b/generateJava.cpp
@@ -19,6 +19,7 @@
 #include "Coordinator.h"
 #include "Interface.h"
 #include "Method.h"
+#include "Reference.h"
 #include "Scope.h"
 
 #include <hidl-util/Formatter.h>
@@ -26,12 +27,9 @@
 
 namespace android {
 
-void AST::emitJavaReaderWriter(
-        Formatter &out,
-        const std::string &parcelObj,
-        const TypedVar *arg,
-        bool isReader,
-        bool addPrefixToName) const {
+void AST::emitJavaReaderWriter(Formatter& out, const std::string& parcelObj,
+                               const NamedReference<Type>* arg, bool isReader,
+                               bool addPrefixToName) const {
     if (isReader) {
         out << arg->type().getJavaType()
             << " "
@@ -45,94 +43,81 @@
             isReader);
 }
 
-status_t AST::generateJavaTypes(
-        const std::string &outputPath, const std::string &limitToType) const {
+void AST::generateJavaTypes(Formatter& out, const std::string& limitToType) const {
     // Splits types.hal up into one java file per declared type.
+    CHECK(!limitToType.empty()) << getFilename();
 
     for (const auto& type : mRootScope.getSubTypes()) {
         std::string typeName = type->localName();
 
-        if (type->isTypeDef()) {
-            continue;
-        }
-
-        if (!limitToType.empty() && typeName != limitToType) {
-            continue;
-        }
-
-        std::string path = outputPath;
-        path.append(mCoordinator->convertPackageRootToPath(mPackage));
-        path.append(mCoordinator->getPackagePath(mPackage, true /* relative */,
-                true /* sanitized */));
-        path.append(typeName);
-        path.append(".java");
-
-        CHECK(Coordinator::MakeParentHierarchy(path)) << path;
-        FILE *file = fopen(path.c_str(), "w");
-
-        if (file == NULL) {
-            return -errno;
-        }
-
-        Formatter out(file);
+        if (type->isTypeDef()) continue;
+        if (typeName != limitToType) continue;
 
         std::vector<std::string> packageComponents;
         getPackageAndVersionComponents(
                 &packageComponents, true /* cpp_compatible */);
 
-        out << "package " << mPackage.javaPackage() << ";\n\n";
+        out << "package " << mPackage.javaPackage() << ";\n\n\n";
 
-        out << "\n";
-
-        status_t err =
-            type->emitJavaTypeDeclarations(out, true /* atTopLevel */);
-
-        if (err != OK) {
-            return err;
-        }
+        type->emitJavaTypeDeclarations(out, true /* atTopLevel */);
+        return;
     }
 
-    return OK;
+    CHECK(false) << "generateJavaTypes could not find limitToType type";
 }
 
-status_t AST::generateJava(
-        const std::string &outputPath, const std::string &limitToType) const {
-    if (!isJavaCompatible()) {
-        fprintf(stderr,
-                "ERROR: This interface is not Java compatible. The Java backend"
-                " does NOT support union types nor native handles. "
-                "In addition, vectors of arrays are limited to at most "
-                "one-dimensional arrays and vectors of {vectors,interfaces} are"
-                " not supported.\n");
-
-        return UNKNOWN_ERROR;
+void emitGetService(
+        Formatter& out,
+        const std::string& ifaceName,
+        const std::string& fqName,
+        bool isRetry) {
+    out << "public static "
+        << ifaceName
+        << " getService(String serviceName";
+    if (isRetry) {
+        out << ", boolean retry";
     }
+    out << ") throws android.os.RemoteException ";
+    out.block([&] {
+        out << "return "
+            << ifaceName
+            << ".asInterface(android.os.HwBinder.getService(\""
+            << fqName
+            << "\", serviceName";
+        if (isRetry) {
+            out << ", retry";
+        }
+        out << "));\n";
+    }).endl().endl();
+
+    out << "public static "
+        << ifaceName
+        << " getService(";
+    if (isRetry) {
+        out << "boolean retry";
+    }
+    out << ") throws android.os.RemoteException ";
+    out.block([&] {
+        out << "return getService(\"default\"";
+        if (isRetry) {
+            out << ", retry";
+        }
+        out <<");\n";
+    }).endl().endl();
+}
+
+void AST::generateJava(Formatter& out, const std::string& limitToType) const {
+    CHECK(isJavaCompatible()) << getFilename();
 
     if (!AST::isInterface()) {
-        return generateJavaTypes(outputPath, limitToType);
+        generateJavaTypes(out, limitToType);
+        return;
     }
 
     const Interface* iface = mRootScope.getInterface();
-    std::string ifaceName = iface->localName();
-
+    const std::string ifaceName = iface->localName();
     const std::string baseName = iface->getBaseName();
 
-    std::string path = outputPath;
-    path.append(mCoordinator->convertPackageRootToPath(mPackage));
-    path.append(mCoordinator->getPackagePath(mPackage, true /* relative */,
-            true /* sanitized */));
-    path.append(ifaceName);
-    path.append(".java");
-
-    CHECK(Coordinator::MakeParentHierarchy(path));
-    FILE *file = fopen(path.c_str(), "w");
-
-    if (file == NULL) {
-        return -errno;
-    }
-
-    Formatter out(file);
-
     std::vector<std::string> packageComponents;
     getPackageAndVersionComponents(
             &packageComponents, true /* cpp_compatible */);
@@ -225,43 +210,10 @@
 
     out << "@Override\npublic android.os.IHwBinder asBinder();\n\n";
 
-    out << "public static "
-        << ifaceName
-        << " getService(String serviceName) throws android.os.RemoteException {\n";
+    emitGetService(out, ifaceName, iface->fqName().string(), true /* isRetry */);
+    emitGetService(out, ifaceName, iface->fqName().string(), false /* isRetry */);
 
-    out.indent();
-
-    out << "return "
-        << ifaceName
-        << ".asInterface(android.os.HwBinder.getService(\""
-        << iface->fqName().string()
-        << "\",serviceName));\n";
-
-    out.unindent();
-
-    out << "}\n\n";
-
-    out << "public static "
-        << ifaceName
-        << " getService() throws android.os.RemoteException {\n";
-
-    out.indent();
-
-    out << "return "
-        << ifaceName
-        << ".asInterface(android.os.HwBinder.getService(\""
-        << iface->fqName().string()
-        << "\",\"default\"));\n";
-
-    out.unindent();
-
-    out << "}\n\n";
-
-    status_t err = emitJavaTypeDeclarations(out);
-
-    if (err != OK) {
-        return err;
-    }
+    emitJavaTypeDeclarations(out);
 
     for (const auto &method : iface->methods()) {
         if (method->isHiddenFromJava()) {
@@ -285,6 +237,8 @@
             out << "}\n\n";
         }
 
+        method->emitDocComment(out);
+
         if (returnsValue && !needsCallback) {
             out << method->results()[0]->type().getJavaType();
         } else {
@@ -342,6 +296,18 @@
             << ifaceName << ".kInterfaceName + \"]@Proxy\";\n";
     }).endl().endl();
 
+    // Equals when internal binder object is equal (even if the interface Proxy object
+    // itself is different). This is similar to interfacesEqual in C++.
+    out << "@Override\npublic final boolean equals(java.lang.Object other) ";
+    out.block([&] {
+        out << "return android.os.HidlSupport.interfacesEqual(this, other);\n";
+    }).endl().endl();
+
+    out << "@Override\npublic final int hashCode() ";
+    out.block([&] {
+        out << "return this.asBinder().hashCode();\n";
+    }).endl().endl();
+
     const Interface *prevInterface = nullptr;
     for (const auto &tuple : iface->allMethodsFromRoot()) {
         const Method *method = tuple.method();
@@ -417,7 +383,7 @@
                 << " */, _hidl_request, _hidl_reply, ";
 
             if (method->isOneway()) {
-                out << "android.os.IHwBinder.FLAG_ONEWAY";
+                out << Interface::FLAG_ONEWAY << " /* oneway */";
             } else {
                 out << "0 /* flags */";
             }
@@ -484,6 +450,8 @@
 
     out << "@Override\npublic android.os.IHwBinder asBinder() {\n";
     out.indent();
+    // If we change this behavior in the future and asBinder does not return "this",
+    // equals and hashCode should also be overridden.
     out << "return this;\n";
     out.unindent();
     out << "}\n\n";
@@ -567,6 +535,15 @@
 
         out.indent();
 
+        out << "boolean _hidl_is_oneway = (_hidl_flags & " << Interface::FLAG_ONEWAY
+            << " /* oneway */) != 0\n;";
+        out << "if (_hidl_is_oneway != " << (method->isOneway() ? "true" : "false") << ") ";
+        out.block([&] {
+            out << "_hidl_reply.writeStatus(" << UNKNOWN_ERROR << ");\n";
+            out << "_hidl_reply.send();\n";
+            out << "break;\n";
+        });
+
         if (method->isHidlReserved() && method->overridesJavaImpl(IMPL_STUB)) {
             method->javaImpl(IMPL_STUB, out);
             out.unindent();
@@ -602,7 +579,7 @@
         }
 
         if (!needsCallback && returnsValue) {
-            const TypedVar *returnArg = method->results()[0];
+            const NamedReference<Type>* returnArg = method->results()[0];
 
             out << returnArg->type().getJavaType()
                 << " _hidl_out_"
@@ -663,7 +640,7 @@
             out << "_hidl_reply.writeStatus(android.os.HwParcel.STATUS_SUCCESS);\n";
 
             if (returnsValue) {
-                const TypedVar *returnArg = method->results()[0];
+                const NamedReference<Type>* returnArg = method->results()[0];
 
                 emitJavaReaderWriter(
                         out,
@@ -692,12 +669,10 @@
 
     out.unindent();
     out << "}\n";
-
-    return OK;
 }
 
-status_t AST::emitJavaTypeDeclarations(Formatter &out) const {
-    return mRootScope.emitJavaTypeDeclarations(out, false /* atTopLevel */);
+void AST::emitJavaTypeDeclarations(Formatter& out) const {
+    mRootScope.emitJavaTypeDeclarations(out, false /* atTopLevel */);
 }
 
 }  // namespace android
diff --git a/generateVts.cpp b/generateVts.cpp
index 5fd8670..8a37ae3 100644
--- a/generateVts.cpp
+++ b/generateVts.cpp
@@ -29,7 +29,7 @@
 
 namespace android {
 
-status_t AST::emitVtsTypeDeclarations(Formatter &out) const {
+void AST::emitVtsTypeDeclarations(Formatter& out) const {
     if (AST::isInterface()) {
         const Interface* iface = mRootScope.getInterface();
         return iface->emitVtsAttributeDeclaration(out);
@@ -42,36 +42,16 @@
         }
         out << "attribute: {\n";
         out.indent();
-        status_t status = type->emitVtsTypeDeclarations(out);
-        if (status != OK) {
-            return status;
-        }
+        type->emitVtsTypeDeclarations(out);
         out.unindent();
         out << "}\n\n";
     }
-
-    return OK;
 }
 
-status_t AST::generateVts(const std::string &outputPath) const {
+void AST::generateVts(Formatter& out) const {
     std::string baseName = AST::getBaseName();
     const Interface *iface = AST::getInterface();
 
-    std::string path = outputPath;
-    path.append(mCoordinator->convertPackageRootToPath(mPackage));
-    path.append(mCoordinator->getPackagePath(mPackage, true /* relative */));
-    path.append(baseName);
-    path.append(".vts");
-
-    CHECK(Coordinator::MakeParentHierarchy(path));
-    FILE *file = fopen(path.c_str(), "w");
-
-    if (file == NULL) {
-        return -errno;
-    }
-
-    Formatter out(file);
-
     out << "component_class: HAL_HIDL\n";
     out << "component_type_version: " << mPackage.version()
         << "\n";
@@ -101,28 +81,19 @@
         std::vector<const Interface *> chain = iface->typeChain();
 
         // Generate all the attribute declarations first.
-        status_t status = emitVtsTypeDeclarations(out);
-        if (status != OK) {
-            return status;
-        }
+        emitVtsTypeDeclarations(out);
+
         // Generate all the method declarations.
         for (auto it = chain.rbegin(); it != chain.rend(); ++it) {
             const Interface *superInterface = *it;
-            status_t status = superInterface->emitVtsMethodDeclaration(out);
-            if (status != OK) {
-                return status;
-            }
+            superInterface->emitVtsMethodDeclaration(out);
         }
 
         out.unindent();
         out << "}\n";
     } else {
-        status_t status = emitVtsTypeDeclarations(out);
-        if (status != OK) {
-            return status;
-        }
+        emitVtsTypeDeclarations(out);
     }
-    return OK;
 }
 
 }  // namespace android
diff --git a/hidl-gen_l.h b/hidl-gen_l.h
new file mode 100644
index 0000000..52237e4
--- /dev/null
+++ b/hidl-gen_l.h
@@ -0,0 +1,32 @@
+/*
+ * Copyright (C) 2018 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include <AST.h>
+
+#include <utils/Errors.h>
+
+#include <stdio.h>
+
+namespace android {
+
+// entry-point for file parsing
+// - contents of file are added to the AST
+// - expects file to already be open
+status_t parseFile(AST* ast, std::unique_ptr<FILE, std::function<void(FILE*)>> file);
+
+}  // namespace android
\ No newline at end of file
diff --git a/hidl-gen_l.ll b/hidl-gen_l.ll
index 13b69bf..c94df01 100644
--- a/hidl-gen_l.ll
+++ b/hidl-gen_l.ll
@@ -14,18 +14,18 @@
  * limitations under the License.
  */
 
-D			[0-9]
-L			[a-zA-Z_]
-H			[a-fA-F0-9]
-E			[Ee][+-]?{D}+
-FS			(f|F|l|L)
-IS			(u|U|l|L)*
+D                   [0-9]
+L                   [a-zA-Z_]
+H                   [a-fA-F0-9]
+E                   [Ee][+-]?{D}+
+FS                  (f|F|l|L)
+IS                  (u|U|l|L)*
 
-COMPONENT               {L}({L}|{D})*
-DOT                     [.]
-AT                      [@]
-VERSION                 {AT}{D}+{DOT}{D}+
-FQNAME                  ({COMPONENT}|{VERSION})(({DOT}|":"+){COMPONENT}|{VERSION})*
+COMPONENT           {L}({L}|{D})*
+DOT                 [.]
+AT                  [@]
+VERSION             {AT}{D}+{DOT}{D}+
+FQNAME              ({COMPONENT}|{VERSION})(({DOT}|":"+){COMPONENT}|{VERSION})*
 
 %{
 
@@ -35,12 +35,14 @@
 #include "CompoundType.h"
 #include "ConstantExpression.h"
 #include "DeathRecipientType.h"
+#include "DocComment.h"
 #include "EnumType.h"
 #include "HandleType.h"
 #include "MemoryType.h"
 #include "Method.h"
 #include "PointerType.h"
 #include "ScalarType.h"
+#include "Scope.h"
 #include "StringType.h"
 #include "VectorType.h"
 #include "RefType.h"
@@ -53,17 +55,23 @@
 using namespace android;
 using token = yy::parser::token;
 
-#define SCALAR_TYPE(kind)                                       \
-    do {                                                        \
-        yylval->type = new ScalarType(ScalarType::kind);        \
-        return token::TYPE;                                   \
-    } while (0)
+static std::string gCurrentComment;
+
+#define SCALAR_TYPE(kind)                                        \
+    {                                                            \
+        yylval->type = new ScalarType(ScalarType::kind, *scope); \
+        return token::TYPE;                                      \
+    }
+
+#define YY_DECL int yylex(YYSTYPE* yylval_param, YYLTYPE* yylloc_param,  \
+    yyscan_t yyscanner, android::Scope** const scope)
 
 #define YY_USER_ACTION yylloc->step(); yylloc->columns(yyleng);
 
 #pragma clang diagnostic push
 #pragma clang diagnostic ignored "-Wunused-parameter"
 #pragma clang diagnostic ignored "-Wdeprecated-register"
+#pragma clang diagnostic ignored "-Wregister"
 
 %}
 
@@ -76,127 +84,135 @@
 %option bison-locations
 
 %x COMMENT_STATE
+%x DOC_COMMENT_STATE
 
 %%
 
-"/*"                 { BEGIN(COMMENT_STATE); }
-<COMMENT_STATE>"*/"  { BEGIN(INITIAL); }
-<COMMENT_STATE>[\n]  { yylloc->lines(); }
-<COMMENT_STATE>.     { }
+"/**"                       { gCurrentComment.clear(); BEGIN(DOC_COMMENT_STATE); }
+<DOC_COMMENT_STATE>"*/"     {
+                                BEGIN(INITIAL);
+                                yylval->docComment = new DocComment(gCurrentComment);
+                                return token::DOC_COMMENT;
+                            }
+<DOC_COMMENT_STATE>[^*\n]*                          { gCurrentComment += yytext; }
+<DOC_COMMENT_STATE>[\n]                             { gCurrentComment += yytext; yylloc->lines(); }
+<DOC_COMMENT_STATE>[*]                              { gCurrentComment += yytext; }
 
-"//"[^\r\n]*         { /* skip C++ style comment */ }
+"/*"                        { BEGIN(COMMENT_STATE); }
+<COMMENT_STATE>"*/"         { BEGIN(INITIAL); }
+<COMMENT_STATE>[\n]         { yylloc->lines(); }
+<COMMENT_STATE>.            { }
 
-"enum"			{ return token::ENUM; }
-"extends"		{ return token::EXTENDS; }
-"generates"		{ return token::GENERATES; }
-"import"		{ return token::IMPORT; }
-"interface"		{ return token::INTERFACE; }
-"package"		{ return token::PACKAGE; }
-"struct"		{ return token::STRUCT; }
-"typedef"		{ return token::TYPEDEF; }
-"union"			{ return token::UNION; }
-"bitfield"		{ yylval->templatedType = new BitFieldType; return token::TEMPLATED; }
-"vec"			{ yylval->templatedType = new VectorType; return token::TEMPLATED; }
-"ref"			{ yylval->templatedType = new RefType; return token::TEMPLATED; }
-"oneway"		{ return token::ONEWAY; }
+"//"[^\r\n]*        { /* skip C++ style comment */ }
 
-"bool"			{ SCALAR_TYPE(KIND_BOOL); }
-"int8_t"		{ SCALAR_TYPE(KIND_INT8); }
-"uint8_t"		{ SCALAR_TYPE(KIND_UINT8); }
-"int16_t"		{ SCALAR_TYPE(KIND_INT16); }
-"uint16_t"		{ SCALAR_TYPE(KIND_UINT16); }
-"int32_t"		{ SCALAR_TYPE(KIND_INT32); }
-"uint32_t"		{ SCALAR_TYPE(KIND_UINT32); }
-"int64_t"		{ SCALAR_TYPE(KIND_INT64); }
-"uint64_t"		{ SCALAR_TYPE(KIND_UINT64); }
-"float"			{ SCALAR_TYPE(KIND_FLOAT); }
-"double"		{ SCALAR_TYPE(KIND_DOUBLE); }
+"enum"              { return token::ENUM; }
+"extends"           { return token::EXTENDS; }
+"generates"         { return token::GENERATES; }
+"import"            { return token::IMPORT; }
+"interface"         { return token::INTERFACE; }
+"package"           { return token::PACKAGE; }
+"struct"            { return token::STRUCT; }
+"typedef"           { return token::TYPEDEF; }
+"union"             { return token::UNION; }
+"bitfield"          { yylval->templatedType = new BitFieldType(*scope); return token::TEMPLATED; }
+"vec"               { yylval->templatedType = new VectorType(*scope); return token::TEMPLATED; }
+"ref"               { yylval->templatedType = new RefType(*scope); return token::TEMPLATED; }
+"oneway"            { return token::ONEWAY; }
 
-"death_recipient"	{ yylval->type = new DeathRecipientType; return token::TYPE; }
-"handle"		{ yylval->type = new HandleType; return token::TYPE; }
-"memory"		{ yylval->type = new MemoryType; return token::TYPE; }
-"pointer"		{ yylval->type = new PointerType; return token::TYPE; }
-"string"		{ yylval->type = new StringType; return token::TYPE; }
+"bool"              { SCALAR_TYPE(KIND_BOOL); }
+"int8_t"            { SCALAR_TYPE(KIND_INT8); }
+"uint8_t"           { SCALAR_TYPE(KIND_UINT8); }
+"int16_t"           { SCALAR_TYPE(KIND_INT16); }
+"uint16_t"          { SCALAR_TYPE(KIND_UINT16); }
+"int32_t"           { SCALAR_TYPE(KIND_INT32); }
+"uint32_t"          { SCALAR_TYPE(KIND_UINT32); }
+"int64_t"           { SCALAR_TYPE(KIND_INT64); }
+"uint64_t"          { SCALAR_TYPE(KIND_UINT64); }
+"float"             { SCALAR_TYPE(KIND_FLOAT); }
+"double"            { SCALAR_TYPE(KIND_DOUBLE); }
 
-"fmq_sync" { yylval->type = new FmqType("::android::hardware", "MQDescriptorSync"); return token::TEMPLATED; }
-"fmq_unsync" { yylval->type = new FmqType("::android::hardware", "MQDescriptorUnsync"); return token::TEMPLATED; }
+"death_recipient"   { yylval->type = new DeathRecipientType(*scope); return token::TYPE; }
+"handle"            { yylval->type = new HandleType(*scope); return token::TYPE; }
+"memory"            { yylval->type = new MemoryType(*scope); return token::TYPE; }
+"pointer"           { yylval->type = new PointerType(*scope); return token::TYPE; }
+"string"            { yylval->type = new StringType(*scope); return token::TYPE; }
 
-"("			{ return('('); }
-")"			{ return(')'); }
-"<"			{ return('<'); }
-">"			{ return('>'); }
-"{"			{ return('{'); }
-"}"			{ return('}'); }
-"["			{ return('['); }
-"]"			{ return(']'); }
-":"			{ return(':'); }
-";"			{ return(';'); }
-","			{ return(','); }
-"."			{ return('.'); }
-"="			{ return('='); }
-"+"			{ return('+'); }
-"-"			{ return('-'); }
-"*"			{ return('*'); }
-"/"			{ return('/'); }
-"%"			{ return('%'); }
-"&"			{ return('&'); }
-"|"			{ return('|'); }
-"^"			{ return('^'); }
-"<<"			{ return(token::LSHIFT); }
-">>"			{ return(token::RSHIFT); }
-"&&"			{ return(token::LOGICAL_AND); }
-"||"			{ return(token::LOGICAL_OR);  }
-"!"			{ return('!'); }
-"~"			{ return('~'); }
-"<="			{ return(token::LEQ); }
-">="			{ return(token::GEQ); }
-"=="			{ return(token::EQUALITY); }
-"!="			{ return(token::NEQ); }
-"?"			{ return('?'); }
-"@"			{ return('@'); }
+"fmq_sync"          { yylval->type = new FmqType("::android::hardware", "MQDescriptorSync", *scope); return token::TEMPLATED; }
+"fmq_unsync"        { yylval->type = new FmqType("::android::hardware", "MQDescriptorUnsync", *scope); return token::TEMPLATED; }
 
-{COMPONENT}                     { yylval->str = strdup(yytext); return token::IDENTIFIER; }
-{FQNAME}                        { yylval->str = strdup(yytext); return token::FQNAME; }
+"("                 { return('('); }
+")"                 { return(')'); }
+"<"                 { return('<'); }
+">"                 { return('>'); }
+"{"                 { return('{'); }
+"}"                 { return('}'); }
+"["                 { return('['); }
+"]"                 { return(']'); }
+":"                 { return(':'); }
+";"                 { return(';'); }
+","                 { return(','); }
+"."                 { return('.'); }
+"="                 { return('='); }
+"+"                 { return('+'); }
+"-"                 { return('-'); }
+"*"                 { return('*'); }
+"/"                 { return('/'); }
+"%"                 { return('%'); }
+"&"                 { return('&'); }
+"|"                 { return('|'); }
+"^"                 { return('^'); }
+"<<"                { return(token::LSHIFT); }
+">>"                { return(token::RSHIFT); }
+"&&"                { return(token::LOGICAL_AND); }
+"||"                { return(token::LOGICAL_OR);  }
+"!"                 { return('!'); }
+"~"                 { return('~'); }
+"<="                { return(token::LEQ); }
+">="                { return(token::GEQ); }
+"=="                { return(token::EQUALITY); }
+"!="                { return(token::NEQ); }
+"?"                 { return('?'); }
+"@"                 { return('@'); }
 
-0[xX]{H}+{IS}?		{ yylval->str = strdup(yytext); return token::INTEGER; }
-0{D}+{IS}?		{ yylval->str = strdup(yytext); return token::INTEGER; }
-{D}+{IS}?		{ yylval->str = strdup(yytext); return token::INTEGER; }
-L?\"(\\.|[^\\"])*\"	{ yylval->str = strdup(yytext); return token::STRING_LITERAL; }
+{COMPONENT}         { yylval->str = strdup(yytext); return token::IDENTIFIER; }
+{FQNAME}            { yylval->str = strdup(yytext); return token::FQNAME; }
 
-{D}+{E}{FS}?		{ yylval->str = strdup(yytext); return token::FLOAT; }
-{D}+\.{E}?{FS}?		{ yylval->str = strdup(yytext); return token::FLOAT; }
-{D}*\.{D}+{E}?{FS}?	{ yylval->str = strdup(yytext); return token::FLOAT; }
+0[xX]{H}+{IS}?      { yylval->str = strdup(yytext); return token::INTEGER; }
+0{D}+{IS}?          { yylval->str = strdup(yytext); return token::INTEGER; }
+{D}+{IS}?           { yylval->str = strdup(yytext); return token::INTEGER; }
+L?\"(\\.|[^\\"])*\" { yylval->str = strdup(yytext); return token::STRING_LITERAL; }
 
-[\n]		{ yylloc->lines(); }
-.			{ /* ignore bad characters */ }
+{D}+{E}{FS}?        { yylval->str = strdup(yytext); return token::FLOAT; }
+{D}+\.{E}?{FS}?     { yylval->str = strdup(yytext); return token::FLOAT; }
+{D}*\.{D}+{E}?{FS}? { yylval->str = strdup(yytext); return token::FLOAT; }
+
+\n|\r\n             { yylloc->lines(); }
+[ \t\f\v]           { /* ignore all other whitespace */ }
+
+.                   { yylval->str = strdup(yytext); return token::UNKNOWN; }
 
 %%
 
 #pragma clang diagnostic pop
 
-status_t parseFile(AST *ast) {
-    FILE *file = fopen(ast->getFilename().c_str(), "rb");
+namespace android {
 
-    if (file == nullptr) {
-        return -errno;
-    }
-
+status_t parseFile(AST* ast, std::unique_ptr<FILE, std::function<void(FILE *)>> file) {
     yyscan_t scanner;
     yylex_init(&scanner);
 
-    yyset_in(file, scanner);
+    yyset_in(file.get(), scanner);
 
     Scope* scopeStack = ast->getRootScope();
     int res = yy::parser(scanner, ast, &scopeStack).parse();
 
     yylex_destroy(scanner);
 
-    fclose(file);
-    file = nullptr;
-
     if (res != 0 || ast->syntaxErrors() != 0) {
         return UNKNOWN_ERROR;
     }
 
     return OK;
 }
+
+}  // namespace android
diff --git a/hidl-gen_y.yy b/hidl-gen_y.yy
index d67638e..f445199 100644
--- a/hidl-gen_y.yy
+++ b/hidl-gen_y.yy
@@ -16,18 +16,20 @@
 
 %{
 
-#include "Annotation.h"
 #include "AST.h"
+#include "Annotation.h"
 #include "ArrayType.h"
 #include "CompoundType.h"
 #include "ConstantExpression.h"
+#include "DocComment.h"
 #include "EnumType.h"
 #include "Interface.h"
 #include "Location.h"
 #include "Method.h"
-#include "Scope.h"
-#include "VectorType.h"
 #include "RefType.h"
+#include "Scope.h"
+#include "TypeDef.h"
+#include "VectorType.h"
 
 #include "hidl-gen_y.h"
 
@@ -38,7 +40,7 @@
 
 using namespace android;
 
-extern int yylex(yy::parser::semantic_type*, yy::parser::location_type*, void*);
+extern int yylex(yy::parser::semantic_type*, yy::parser::location_type*, void*, Scope** const);
 
 void enterScope(AST* /* ast */, Scope** scope, Scope* container) {
     CHECK(container->parent() == (*scope));
@@ -205,6 +207,7 @@
 %parse-param { android::AST* const ast }
 %parse-param { android::Scope** const scope }
 %lex-param { void* scanner }
+%lex-param { android::Scope** const scope }
 %pure-parser
 %glr-parser
 %skeleton "glr.cc"
@@ -212,23 +215,28 @@
 %expect-rr 0
 %error-verbose
 
-%token<str> ENUM "keyword `enum`"
-%token<str> EXTENDS "keyword `extends`"
+%debug
+
+%token<docComment> DOC_COMMENT "doc comment"
+
+%token<void> ENUM "keyword `enum`"
+%token<void> EXTENDS "keyword `extends`"
 %token<str> FQNAME "fully-qualified name"
-%token<str> GENERATES "keyword `generates`"
+%token<void> GENERATES "keyword `generates`"
 %token<str> IDENTIFIER "identifier"
-%token<str> IMPORT "keyword `import`"
+%token<void> IMPORT "keyword `import`"
 %token<str> INTEGER "integer value"
 %token<str> FLOAT "float value"
-%token<str> INTERFACE "keyword `interface`"
+%token<void> INTERFACE "keyword `interface`"
 %token<str> PACKAGE "keyword `package`"
 %token<type> TYPE "type"
-%token<str> STRUCT "keyword `struct`"
+%token<void> STRUCT "keyword `struct`"
 %token<str> STRING_LITERAL "string literal"
-%token<str> TYPEDEF "keyword `typedef`"
-%token<str> UNION "keyword `union`"
+%token<void> TYPEDEF "keyword `typedef`"
+%token<void> UNION "keyword `union`"
 %token<templatedType> TEMPLATED "templated type"
 %token<void> ONEWAY "keyword `oneway`"
+%token<str> UNKNOWN "unknown character"
 
 /* Operator precedence and associativity, as per
  * http://en.cppreference.com/w/cpp/language/operator_precedence */
@@ -254,28 +262,31 @@
 /* Precedence level 3, RTL; but we have to use %left here */
 %left UNARY_MINUS UNARY_PLUS '!' '~'
 
+%type<docComment> doc_comments
+
 %type<str> error_stmt error
 %type<str> package
 %type<fqName> fqname
-%type<type> fqtype
+%type<referenceToType> fqtype
 %type<str> valid_identifier valid_type_name
 
-%type<type> type enum_storage_type
-%type<type> array_type_base
+%type<referenceToType> type enum_storage_type type_or_inplace_compound_declaration
+%type<referenceToType> array_type_base
 %type<arrayType> array_type
-%type<type> opt_extends
-%type<type> type_declaration type_declaration_body interface_declaration typedef_declaration
+%type<referenceToType> opt_extends
+%type<type> type_declaration commentable_type_declaration type_declaration_body
+%type<type> interface_declaration typedef_declaration
 %type<type> named_struct_or_union_declaration named_enum_declaration
 %type<type> compound_declaration annotated_compound_declaration
 
-%type<field> field_declaration
+%type<field> field_declaration commentable_field_declaration
 %type<fields> field_declarations struct_or_union_body
 %type<constantExpression> const_expr
-%type<enumValue> enum_value
+%type<enumValue> enum_value commentable_enum_value
 %type<enumValues> enum_values enum_declaration_body
 %type<typedVars> typed_vars
 %type<typedVar> typed_var
-%type<method> method_declaration
+%type<method> method_declaration commentable_method_declaration
 %type<compoundStyle> struct_or_union_keyword
 %type<stringVec> annotation_string_values annotation_string_value
 %type<constExprVec> annotation_const_expr_values annotation_const_expr_value
@@ -288,17 +299,18 @@
 
 %union {
     const char *str;
-    android::Type *type;
+    android::Type* type;
+    android::Reference<android::Type>* referenceToType;
     android::ArrayType *arrayType;
     android::TemplatedType *templatedType;
     android::FQName *fqName;
     android::CompoundType *compoundType;
-    android::CompoundField *field;
-    std::vector<android::CompoundField *> *fields;
+    android::NamedReference<android::Type>* field;
+    std::vector<android::NamedReference<android::Type>*>* fields;
     android::EnumValue *enumValue;
     android::ConstantExpression *constantExpression;
     std::vector<android::EnumValue *> *enumValues;
-    android::TypedVar *typedVar;
+    android::NamedReference<android::Type>* typedVar;
     android::TypedVarVector *typedVars;
     android::Method *method;
     android::CompoundType::Style compoundStyle;
@@ -308,14 +320,29 @@
     android::AnnotationParamVector *annotationParams;
     android::Annotation *annotation;
     std::vector<android::Annotation *> *annotations;
+    android::DocComment* docComment;
 }
 
 %%
 
 program
-    : package
-      imports
-      type_declarations
+    // Don't care if license header is a doc comment or not
+    : DOC_COMMENT package imports type_declarations
+    | package imports type_declarations
+    ;
+
+doc_comments
+    : DOC_COMMENT { $$ = $1; }
+    | doc_comments DOC_COMMENT
+      {
+        $1->merge($2);
+        $$ = $1;
+      }
+    | doc_comments '}'
+      {
+        std::cerr << "ERROR: Doc comments must preceed what they describe at " << @1 << "\n";
+        YYERROR;
+      }
     ;
 
 valid_identifier
@@ -388,11 +415,11 @@
 annotation_param
     : IDENTIFIER '=' annotation_string_value
       {
-          $$ = new AnnotationParam($1, $3);
+          $$ = new StringAnnotationParam($1, $3);
       }
     | IDENTIFIER '=' annotation_const_expr_value
       {
-          $$ = new AnnotationParam($1, $3);
+          $$ = new ConstantExpressionAnnotationParam($1, $3);
       }
     ;
 
@@ -460,8 +487,8 @@
 fqname
     : FQNAME
       {
-          $$ = new FQName($1);
-          if(!$$->isValid()) {
+          $$ = new FQName();
+          if(!FQName::parse($1, $$)) {
               std::cerr << "ERROR: FQName '" << $1 << "' is not valid at "
                         << @1
                         << ".\n";
@@ -470,8 +497,8 @@
       }
     | valid_type_name
       {
-          $$ = new FQName($1);
-          if(!$$->isValid()) {
+          $$ = new FQName();
+          if(!FQName::parse($1, $$)) {
               std::cerr << "ERROR: FQName '" << $1 << "' is not valid at "
                         << @1
                         << ".\n";
@@ -483,16 +510,12 @@
 fqtype
     : fqname
       {
-          $$ = ast->lookupType(*($1), *scope);
-          if ($$ == NULL) {
-              std::cerr << "ERROR: Failed to lookup type '" << $1->string() << "' at "
-                        << @1
-                        << "\n";
-
-              YYERROR;
-          }
+          $$ = new Reference<Type>(*$1, convertYYLoc(@1));
       }
     | TYPE
+      {
+          $$ = new Reference<Type>($1, convertYYLoc(@1));
+      }
     ;
 
 package
@@ -543,25 +566,29 @@
     ;
 
 opt_extends
-    : /* empty */ { $$ = NULL; }
+    : /* empty */ { $$ = nullptr; }
     | EXTENDS fqtype { $$ = $2; }
+    ;
 
 interface_declarations
     : /* empty */
-    | interface_declarations type_declaration
+    | interface_declarations commentable_type_declaration
       {
+          CHECK((*scope)->isInterface());
+
           std::string errorMsg;
-          if ($2 != nullptr &&
-              $2->isNamedType() &&
-              !isValidInterfaceField(static_cast<NamedType *>($2)->localName().c_str(),
+          if ($2 != nullptr && $2->isNamedType() &&
+              !isValidInterfaceField(static_cast<NamedType*>($2)->localName().c_str(),
                     &errorMsg)) {
               std::cerr << "ERROR: " << errorMsg << " at "
                         << @2 << "\n";
               YYERROR;
           }
       }
-    | interface_declarations method_declaration
+    | interface_declarations commentable_method_declaration
       {
+          CHECK((*scope)->isInterface());
+
           std::string errorMsg;
           if ($2 != nullptr &&
               !isValidInterfaceField($2->name().c_str(), &errorMsg)) {
@@ -571,13 +598,7 @@
           }
 
           if ($2 != nullptr) {
-            if (!(*scope)->isInterface()) {
-                std::cerr << "ERROR: unknown error in interface declaration at "
-                    << @2 << "\n";
-                YYERROR;
-            }
-
-            Interface *iface = static_cast<Interface *>(*scope);
+            Interface *iface = static_cast<Interface*>(*scope);
             if (!iface->addMethod($2)) {
                 std::cerr << "ERROR: Unable to add method '" << $2->name()
                           << "' at " << @2 << "\n";
@@ -592,19 +613,29 @@
 type_declarations
     : /* empty */
     | error_stmt
-    | type_declarations type_declaration
+    | type_declarations commentable_type_declaration
+    ;
+
+commentable_type_declaration
+    : doc_comments type_declaration
+      {
+        $2->setDocComment($1);
+        $$ = $2;
+      }
+    | type_declaration { $$ = $1; }
     ;
 
 type_declaration
     : opt_annotations type_declaration_body
       {
-          if ($2 != nullptr) {
-              $2->setAnnotations($1);
+          if (!$2->isTypeDef()) {
+              CHECK($2->isScope());
+              static_cast<Scope*>($2)->setAnnotations($1);
           } else if (!$1->empty()) {
               // Since typedefs are always resolved to their target it makes
               // little sense to annotate them and have their annotations
               // impose semantics other than their target type.
-              std::cerr << "ERROR: typedefs cannot be annotated. at " << @2
+              std::cerr << "ERROR: typedefs cannot be annotated at " << @2
                         << "\n";
 
               YYERROR;
@@ -623,9 +654,18 @@
 interface_declaration
     : INTERFACE valid_type_name opt_extends
       {
-          Type *parent = $3;
+          Reference<Type>* superType = $3;
+          bool isIBase = ast->package().package() == gIBaseFqName.package();
 
-          if (ast->package().package() != gIBasePackageFqName.string()) {
+          if (isIBase) {
+              if (superType != nullptr) {
+                  std::cerr << "ERROR: IBase must not extend any interface at " << @3
+                        << "\n";
+
+                  YYERROR;
+              }
+              superType = new Reference<Type>();
+          } else {
               if (!ast->addImport(gIBaseFqName.string().c_str())) {
                   std::cerr << "ERROR: Unable to automatically import '"
                             << gIBaseFqName.string()
@@ -633,63 +673,41 @@
                             << "\n";
                   YYERROR;
               }
-              if (parent == nullptr) {
-                parent = ast->lookupType(gIBaseFqName, *scope);
+
+              if (superType == nullptr) {
+                  superType = new Reference<Type>(gIBaseFqName, convertYYLoc(@$));
               }
           }
 
-          if (parent != NULL && !parent->isInterface()) {
-              std::cerr << "ERROR: You can only extend interfaces. at " << @3
-                        << "\n";
-
-              YYERROR;
-          }
-
           if ($2[0] != 'I') {
               std::cerr << "ERROR: All interface names must start with an 'I' "
-                        << "prefix. at " << @2 << "\n";
+                        << "prefix at " << @2 << "\n";
 
               YYERROR;
           }
 
           if (*scope != ast->getRootScope()) {
               std::cerr << "ERROR: All interface must declared in "
-                        << "global scope. at " << @2 << "\n";
+                        << "global scope at " << @2 << "\n";
 
               YYERROR;
           }
 
           Interface* iface = new Interface(
-              $2, convertYYLoc(@2), *scope,
-              static_cast<Interface *>(parent));
-
-          // Register interface immediately so it can be referenced inside
-          // definition.
-          std::string errorMsg;
-          if (!ast->addScopedType(iface, &errorMsg, *scope)) {
-              std::cerr << "ERROR: " << errorMsg << " at " << @2 << "\n";
-              YYERROR;
-          }
+              $2, ast->makeFullName($2, *scope), convertYYLoc(@2),
+              *scope, *superType, ast->getFileHash());
 
           enterScope(ast, scope, iface);
       }
       '{' interface_declarations '}'
       {
-          if (!(*scope)->isInterface()) {
-              std::cerr << "ERROR: unknown error in interface declaration at "
-                  << @5 << "\n";
-              YYERROR;
-          }
+          CHECK((*scope)->isInterface());
 
           Interface *iface = static_cast<Interface *>(*scope);
-          if (!iface->addAllReservedMethods()) {
-              std::cerr << "ERROR: unknown error in adding reserved methods at "
-                  << @5 << "\n";
-              YYERROR;
-          }
+          CHECK(iface->addAllReservedMethods());
 
           leaveScope(ast, scope);
-
+          ast->addScopedType(iface, *scope);
           $$ = iface;
       }
     ;
@@ -697,18 +715,26 @@
 typedef_declaration
     : TYPEDEF type valid_type_name
       {
-          std::string errorMsg;
-          if (!ast->addTypeDef($3, $2, convertYYLoc(@3), &errorMsg, *scope)) {
-              std::cerr << "ERROR: " << errorMsg << " at " << @3 << "\n";
-              YYERROR;
-          }
-
-          $$ = nullptr;
+          // The reason we wrap the given type in a TypeDef is simply to suppress
+          // emitting any type definitions later on, since this is just an alias
+          // to a type defined elsewhere.
+          TypeDef* typeDef = new TypeDef(
+              $3, ast->makeFullName($3, *scope), convertYYLoc(@2), *scope, *$2);
+          ast->addScopedType(typeDef, *scope);
+          $$ = typeDef;
       }
     ;
 
 const_expr
-    : INTEGER                   { $$ = new ConstantExpression($1); }
+    : INTEGER                   {
+          $$ = LiteralConstantExpression::tryParse($1);
+
+          if ($$ == nullptr) {
+              std::cerr << "ERROR: Could not parse literal: "
+                        << $1 << " at " << @1 << ".\n";
+              YYERROR;
+          }
+      }
     | fqname
       {
           if(!$1->isValidValueName()) {
@@ -717,79 +743,89 @@
                         << @1 << ".\n";
               YYERROR;
           }
-          if($1->isIdentifier()) {
-              std::string identifier = $1->name();
-              LocalIdentifier *iden = (*scope)->lookupIdentifier(identifier);
-              if(!iden) {
-                  std::cerr << "ERROR: identifier " << $1->string()
-                            << " could not be found at " << @1 << ".\n";
-                  YYERROR;
-              }
-              if(!iden->isEnumValue()) {
-                  std::cerr << "ERROR: identifier " << $1->string()
-                            << " is not an enum value at " << @1 << ".\n";
-                  YYERROR;
-              }
-              $$ = new ConstantExpression(
-                      *(static_cast<EnumValue *>(iden)->constExpr()), $1->string());
-          } else {
-              std::string errorMsg;
-              EnumValue *v = ast->lookupEnumValue(*($1), &errorMsg, *scope);
-              if(v == nullptr) {
-                  std::cerr << "ERROR: " << errorMsg << " at " << @1 << ".\n";
-                  YYERROR;
-              }
-              $$ = new ConstantExpression(*(v->constExpr()), $1->string());
-          }
+
+          $$ = new ReferenceConstantExpression(
+              Reference<LocalIdentifier>(*$1, convertYYLoc(@1)), $1->string());
       }
     | const_expr '?' const_expr ':' const_expr
       {
-          $$ = new ConstantExpression($1, $3, $5);
+          $$ = new TernaryConstantExpression($1, $3, $5);
       }
-    | const_expr LOGICAL_OR const_expr  { $$ = new ConstantExpression($1, "||", $3); }
-    | const_expr LOGICAL_AND const_expr { $$ = new ConstantExpression($1, "&&", $3); }
-    | const_expr '|' const_expr { $$ = new ConstantExpression($1, "|" , $3); }
-    | const_expr '^' const_expr { $$ = new ConstantExpression($1, "^" , $3); }
-    | const_expr '&' const_expr { $$ = new ConstantExpression($1, "&" , $3); }
-    | const_expr EQUALITY const_expr { $$ = new ConstantExpression($1, "==", $3); }
-    | const_expr NEQ const_expr { $$ = new ConstantExpression($1, "!=", $3); }
-    | const_expr '<' const_expr { $$ = new ConstantExpression($1, "<" , $3); }
-    | const_expr '>' const_expr { $$ = new ConstantExpression($1, ">" , $3); }
-    | const_expr LEQ const_expr { $$ = new ConstantExpression($1, "<=", $3); }
-    | const_expr GEQ const_expr { $$ = new ConstantExpression($1, ">=", $3); }
-    | const_expr LSHIFT const_expr { $$ = new ConstantExpression($1, "<<", $3); }
-    | const_expr RSHIFT const_expr { $$ = new ConstantExpression($1, ">>", $3); }
-    | const_expr '+' const_expr { $$ = new ConstantExpression($1, "+" , $3); }
-    | const_expr '-' const_expr { $$ = new ConstantExpression($1, "-" , $3); }
-    | const_expr '*' const_expr { $$ = new ConstantExpression($1, "*" , $3); }
-    | const_expr '/' const_expr { $$ = new ConstantExpression($1, "/" , $3); }
-    | const_expr '%' const_expr { $$ = new ConstantExpression($1, "%" , $3); }
-    | '+' const_expr %prec UNARY_PLUS  { $$ = new ConstantExpression("+", $2); }
-    | '-' const_expr %prec UNARY_MINUS { $$ = new ConstantExpression("-", $2); }
-    | '!' const_expr { $$ = new ConstantExpression("!", $2); }
-    | '~' const_expr { $$ = new ConstantExpression("~", $2); }
+    | const_expr LOGICAL_OR const_expr  { $$ = new BinaryConstantExpression($1, "||", $3); }
+    | const_expr LOGICAL_AND const_expr { $$ = new BinaryConstantExpression($1, "&&", $3); }
+    | const_expr '|' const_expr { $$ = new BinaryConstantExpression($1, "|" , $3); }
+    | const_expr '^' const_expr { $$ = new BinaryConstantExpression($1, "^" , $3); }
+    | const_expr '&' const_expr { $$ = new BinaryConstantExpression($1, "&" , $3); }
+    | const_expr EQUALITY const_expr { $$ = new BinaryConstantExpression($1, "==", $3); }
+    | const_expr NEQ const_expr { $$ = new BinaryConstantExpression($1, "!=", $3); }
+    | const_expr '<' const_expr { $$ = new BinaryConstantExpression($1, "<" , $3); }
+    | const_expr '>' const_expr { $$ = new BinaryConstantExpression($1, ">" , $3); }
+    | const_expr LEQ const_expr { $$ = new BinaryConstantExpression($1, "<=", $3); }
+    | const_expr GEQ const_expr { $$ = new BinaryConstantExpression($1, ">=", $3); }
+    | const_expr LSHIFT const_expr { $$ = new BinaryConstantExpression($1, "<<", $3); }
+    | const_expr RSHIFT const_expr { $$ = new BinaryConstantExpression($1, ">>", $3); }
+    | const_expr '+' const_expr { $$ = new BinaryConstantExpression($1, "+" , $3); }
+    | const_expr '-' const_expr { $$ = new BinaryConstantExpression($1, "-" , $3); }
+    | const_expr '*' const_expr { $$ = new BinaryConstantExpression($1, "*" , $3); }
+    | const_expr '/' const_expr { $$ = new BinaryConstantExpression($1, "/" , $3); }
+    | const_expr '%' const_expr { $$ = new BinaryConstantExpression($1, "%" , $3); }
+    | '+' const_expr %prec UNARY_PLUS  { $$ = new UnaryConstantExpression("+", $2); }
+    | '-' const_expr %prec UNARY_MINUS { $$ = new UnaryConstantExpression("-", $2); }
+    | '!' const_expr { $$ = new UnaryConstantExpression("!", $2); }
+    | '~' const_expr { $$ = new UnaryConstantExpression("~", $2); }
     | '(' const_expr ')' { $$ = $2; }
     | '(' error ')'
       {
         ast->addSyntaxError();
         // to avoid segfaults
-        $$ = new ConstantExpression(ConstantExpression::Zero(ScalarType::KIND_INT32));
+        $$ = ConstantExpression::Zero(ScalarType::KIND_INT32).release();
       }
     ;
 
+commentable_method_declaration
+    : doc_comments method_declaration
+      {
+        if ($2 != nullptr) $2->setDocComment($1);
+        $$ = $2;
+      }
+    | method_declaration
+      {
+        $$ = $1;
+      }
+
 method_declaration
     : error_stmt { $$ = nullptr; }
     | opt_annotations valid_identifier '(' typed_vars ')' require_semicolon
       {
-          $$ = new Method($2, $4, new std::vector<TypedVar *>, false, $1);
+          $$ = new Method($2 /* name */,
+                          $4 /* args */,
+                          new std::vector<NamedReference<Type>*> /* results */,
+                          false /* oneway */,
+                          $1 /* annotations */,
+                          convertYYLoc(@$));
       }
     | opt_annotations ONEWAY valid_identifier '(' typed_vars ')' require_semicolon
       {
-          $$ = new Method($3, $5, new std::vector<TypedVar *>, true, $1);
+          $$ = new Method($3 /* name */,
+                          $5 /* args */,
+                          new std::vector<NamedReference<Type>*> /* results */,
+                          true /* oneway */,
+                          $1 /* annotations */,
+                          convertYYLoc(@$));
       }
     | opt_annotations valid_identifier '(' typed_vars ')' GENERATES '(' typed_vars ')' require_semicolon
       {
-          $$ = new Method($2, $4, $8, false, $1);
+          if ($8->empty()) {
+              std::cerr << "ERROR: generates clause used without result at " << @1 << "\n";
+              ast->addSyntaxError();
+          }
+
+          $$ = new Method($2 /* name */,
+                          $4 /* args */,
+                          $8 /* results */,
+                          false /* oneway */,
+                          $1 /* annotations */,
+                          convertYYLoc(@$));
       }
     ;
 
@@ -818,7 +854,22 @@
       }
     ;
 
-typed_var : type valid_identifier { $$ = new TypedVar($2, $1); }
+typed_var
+    : type valid_identifier
+      {
+          $$ = new NamedReference<Type>($2, *$1, convertYYLoc(@2));
+      }
+    | type
+      {
+          $$ = new NamedReference<Type>("", *$1, convertYYLoc(@1));
+
+          const std::string typeName = $$->isResolved()
+              ? $$->get()->typeName() : $$->getLookupFqName().string();
+
+          std::cerr << "ERROR: variable of type " << typeName
+              << " is missing a variable name at " << @1 << "\n";
+          ast->addSyntaxError();
+      }
     ;
 
 
@@ -830,31 +881,18 @@
 named_struct_or_union_declaration
     : struct_or_union_keyword valid_type_name
       {
-          CompoundType *container = new CompoundType($1, $2, convertYYLoc(@2), *scope);
+          CompoundType *container = new CompoundType(
+              $1, $2, ast->makeFullName($2, *scope), convertYYLoc(@2), *scope);
           enterScope(ast, scope, container);
       }
       struct_or_union_body
       {
-          if (!(*scope)->isCompoundType()) {
-              std::cerr << "ERROR: unknown error in struct or union declaration at "
-                  << @4 << "\n";
-              YYERROR;
-          }
+          CHECK((*scope)->isCompoundType());
           CompoundType *container = static_cast<CompoundType *>(*scope);
-
-          std::string errorMsg;
-          if (!container->setFields($4, &errorMsg)) {
-              std::cerr << "ERROR: " << errorMsg << " at " << @4 << "\n";
-              YYERROR;
-          }
+          container->setFields($4);
 
           leaveScope(ast, scope);
-
-          if (!ast->addScopedType(container, &errorMsg, *scope)) {
-              std::cerr << "ERROR: " << errorMsg << " at " << @2 << "\n";
-              YYERROR;
-          }
-
+          ast->addScopedType(container, *scope);
           $$ = container;
       }
     ;
@@ -864,51 +902,63 @@
     ;
 
 field_declarations
-    : /* empty */ { $$ = new std::vector<CompoundField *>; }
-    | field_declarations field_declaration
+    : /* empty */ { $$ = new std::vector<NamedReference<Type>*>; }
+    | field_declarations commentable_field_declaration
       {
           $$ = $1;
 
-          if ($2 != NULL) {
+          // Compound declaration or error
+          if ($2 != nullptr) {
               $$->push_back($2);
           }
       }
     ;
 
+commentable_field_declaration
+    : doc_comments field_declaration
+    {
+      if ($2 != nullptr) $2->setDocComment($1);
+      $$ = $2;
+    }
+    | field_declaration { $$ = $1; }
+
 field_declaration
     : error_stmt { $$ = nullptr; }
-    | type valid_identifier require_semicolon
+    | type_or_inplace_compound_declaration valid_identifier require_semicolon
       {
-        std::string errorMsg;
-        if ((*scope)->isCompoundType() &&
-            static_cast<CompoundType *>(*scope)->style() == CompoundType::STYLE_STRUCT &&
-            !isValidStructField($2, &errorMsg)) {
-            std::cerr << "ERROR: " << errorMsg << " at "
-                      << @2 << "\n";
-            YYERROR;
-        }
-        $$ = new CompoundField($2, $1);
+          CHECK((*scope)->isCompoundType());
+
+          std::string errorMsg;
+          if (static_cast<CompoundType *>(*scope)->style() == CompoundType::STYLE_STRUCT &&
+              !isValidStructField($2, &errorMsg)) {
+              std::cerr << "ERROR: " << errorMsg << " at "
+                        << @2 << "\n";
+              YYERROR;
+          }
+          $$ = new NamedReference<Type>($2, *$1, convertYYLoc(@2));
       }
     | annotated_compound_declaration ';'
       {
-        std::string errorMsg;
-        if ((*scope)->isCompoundType() &&
-            static_cast<CompoundType *>(*scope)->style() == CompoundType::STYLE_STRUCT &&
-            $1 != nullptr &&
-            $1->isNamedType() &&
-            !isValidStructField(static_cast<NamedType *>($1)->localName().c_str(), &errorMsg)) {
-            std::cerr << "ERROR: " << errorMsg << " at "
-                      << @2 << "\n";
-            YYERROR;
-        }
-        $$ = NULL;
+          CHECK((*scope)->isCompoundType());
+
+          std::string errorMsg;
+          if (static_cast<CompoundType *>(*scope)->style() == CompoundType::STYLE_STRUCT &&
+              $1 != nullptr && $1->isNamedType() &&
+              !isValidStructField(static_cast<NamedType*>($1)->localName().c_str(), &errorMsg)) {
+              std::cerr << "ERROR: " << errorMsg << " at "
+                        << @2 << "\n";
+              YYERROR;
+          }
+          // Returns fields only
+          $$ = nullptr;
       }
     ;
 
 annotated_compound_declaration
     : opt_annotations compound_declaration
       {
-          $2->setAnnotations($1);
+          CHECK($2->isScope());
+          static_cast<Scope*>($2)->setAnnotations($1);
           $$ = $2;
       }
     ;
@@ -919,19 +969,8 @@
     ;
 
 enum_storage_type
-    : ':' fqtype
-      {
-          $$ = $2;
-
-          if ($$ != NULL && !$$->isValidEnumStorageType()) {
-              std::cerr << "ERROR: Invalid enum storage type ("
-                        << $2->typeName()
-                        << ") specified. at "
-                        << @2 << "\n";
-
-              YYERROR;
-          }
-      }
+    : ':' fqtype { $$ = $2; }
+    | /* empty */ { $$ = nullptr; }
     ;
 
 opt_comma
@@ -942,25 +981,27 @@
 named_enum_declaration
     : ENUM valid_type_name enum_storage_type
       {
-          enterScope(ast, scope, new EnumType($2, convertYYLoc(@2), $3, *scope));
+          auto storageType = $3;
+
+          if (storageType == nullptr) {
+              std::cerr << "ERROR: Must explicitly specify enum storage type for "
+                        << $2 << " at " << @2 << "\n";
+              ast->addSyntaxError();
+              storageType = new Reference<Type>(
+                  new ScalarType(ScalarType::KIND_INT64, *scope), convertYYLoc(@2));
+          }
+
+          EnumType* enumType = new EnumType(
+              $2, ast->makeFullName($2, *scope), convertYYLoc(@2), *storageType, *scope);
+          enterScope(ast, scope, enumType);
       }
       enum_declaration_body
       {
-          if (!(*scope)->isEnum()) {
-              std::cerr << "ERROR: unknown error in enum declaration at "
-                  << @5 << "\n";
-              YYERROR;
-          }
+          CHECK((*scope)->isEnum());
+          EnumType* enumType = static_cast<EnumType*>(*scope);
 
-          EnumType *enumType = static_cast<EnumType *>(*scope);
           leaveScope(ast, scope);
-
-          std::string errorMsg;
-          if (!ast->addScopedType(enumType, &errorMsg, *scope)) {
-              std::cerr << "ERROR: " << errorMsg << " at " << @2 << "\n";
-              YYERROR;
-          }
-
+          ast->addScopedType(enumType, *scope);
           $$ = enumType;
       }
     ;
@@ -969,83 +1010,74 @@
     : '{' enum_values opt_comma '}' { $$ = $2; }
     ;
 
+commentable_enum_value
+    : doc_comments enum_value
+      {
+        $2->setDocComment($1);
+        $$ = $2;
+      }
+    | enum_value { $$ = $1; }
+    ;
+
 enum_value
-    : valid_identifier { $$ = new EnumValue($1); }
-    | valid_identifier '=' const_expr { $$ = new EnumValue($1, $3); }
+    : valid_identifier
+      {
+          $$ = new EnumValue($1 /* name */, nullptr /* value */, convertYYLoc(@$));
+      }
+    | valid_identifier '=' const_expr
+      {
+          $$ = new EnumValue($1 /* name */, $3 /* value */, convertYYLoc(@$));
+      }
     ;
 
 enum_values
     : /* empty */
       { /* do nothing */ }
-    | enum_value
+    | commentable_enum_value
       {
-          if (!(*scope)->isEnum()) {
-              std::cerr << "ERROR: unknown error in enum declaration at "
-                  << @1 << "\n";
-              YYERROR;
-          }
-
+          CHECK((*scope)->isEnum());
           static_cast<EnumType *>(*scope)->addValue($1);
       }
-    | enum_values ',' enum_value
+    | enum_values ',' commentable_enum_value
       {
-          if (!(*scope)->isEnum()) {
-              std::cerr << "ERROR: unknown error in enum declaration at "
-                  << @3 << "\n";
-              YYERROR;
-          }
-
+          CHECK((*scope)->isEnum());
           static_cast<EnumType *>(*scope)->addValue($3);
       }
+    | error ',' commentable_enum_value
+      {
+          ast->addSyntaxError();
+
+          CHECK((*scope)->isEnum());
+          static_cast<EnumType *>(*scope)->addValue($3);
+      }
+    | enum_values ',' error ',' commentable_enum_value
+      {
+          ast->addSyntaxError();
+
+          CHECK((*scope)->isEnum());
+          static_cast<EnumType *>(*scope)->addValue($5);
+      }
     ;
 
 array_type_base
     : fqtype { $$ = $1; }
     | TEMPLATED '<' type '>'
       {
-          if (!$1->isCompatibleElementType($3)) {
-              std::cerr << "ERROR: " << $1->typeName() << " of " << $3->typeName()
-                        << " is not supported. at " << @3 << "\n";
-
-              YYERROR;
-          }
-          $1->setElementType($3);
-          $$ = $1;
+          $1->setElementType(*$3);
+          $$ = new Reference<Type>($1, convertYYLoc(@1));
       }
     | TEMPLATED '<' TEMPLATED '<' type RSHIFT
       {
-          if (!$3->isCompatibleElementType($5)) {
-              std::cerr << "ERROR: " << $3->typeName() << " of " << $5->typeName()
-                        << " is not supported. at " << @3 << "\n";
-
-              YYERROR;
-          }
-          $3->setElementType($5);
-          if (!$1->isCompatibleElementType($3)) {
-              std::cerr << "ERROR: " << $1->typeName() << " of " << $3->typeName()
-                        << " is not supported. at " << @3 << "\n";
-
-              YYERROR;
-          }
-          $1->setElementType($3);
-          $$ = $1;
+          $3->setElementType(*$5);
+          $1->setElementType(Reference<Type>($3, convertYYLoc(@3)));
+          $$ = new Reference<Type>($1, convertYYLoc(@1));
       }
     ;
 
 array_type
     : array_type_base '[' const_expr ']'
       {
-          if ($1->isBinder()) {
-              std::cerr << "ERROR: Arrays of interface types are not supported."
-                        << " at " << @1 << "\n";
-
-              YYERROR;
-          }
-          if ($1->isArray()) {
-              $$ = new ArrayType(static_cast<ArrayType *>($1), $3);
-          } else {
-              $$ = new ArrayType($1, $3);
-          }
+          $$ = new ArrayType(*$1, $3, *scope);
       }
     | array_type '[' const_expr ']'
       {
@@ -1056,26 +1088,24 @@
 
 type
     : array_type_base { $$ = $1; }
-    | array_type { $$ = $1; }
-    | annotated_compound_declaration { $$ = $1; }
+    | array_type { $$ = new Reference<Type>($1, convertYYLoc(@1)); }
     | INTERFACE
       {
           // "interface" is a synonym of android.hidl.base@1.0::IBase
-          $$ = ast->lookupType(gIBaseFqName, *scope);
-          if ($$ == nullptr) {
-              std::cerr << "ERROR: Cannot find "
-                        << gIBaseFqName.string()
-                        << " at " << @1 << "\n";
-
-              YYERROR;
+          $$ = new Reference<Type>(gIBaseFqName, convertYYLoc(@1));
       }
-    }
+    ;
+
+type_or_inplace_compound_declaration
+    : type { $$ = $1; }
+    | annotated_compound_declaration
+      {
+          $$ = new Reference<Type>($1, convertYYLoc(@1));
+      }
     ;
 
 %%
 
-#include <android-base/logging.h>
-
 void yy::parser::error(
         const yy::parser::location_type &where,
         const std::string &errstr) {
diff --git a/include_hash/hidl-hash/Hash.h b/include_hash/hidl-hash/Hash.h
index 71a96e8..e443ef5 100644
--- a/include_hash/hidl-hash/Hash.h
+++ b/include_hash/hidl-hash/Hash.h
@@ -23,15 +23,18 @@
 namespace android {
 
 struct Hash {
+    static const std::vector<uint8_t> kEmptyHash;
+
     // path to .hal file
     static const Hash &getHash(const std::string &path);
+    static void clearHash(const std::string& path);
 
     // returns matching hashes of interfaceName in path
     // path is something like hardware/interfaces/current.txt
     // interfaceName is something like android.hardware.foo@1.0::IFoo
-    static std::vector<std::string> lookupHash(const std::string &path,
-                                               const std::string &interfaceName,
-                                               std::string *err);
+    static std::vector<std::string> lookupHash(const std::string& path,
+                                               const std::string& interfaceName, std::string* err,
+                                               bool* fileExists = nullptr);
 
     static std::string hexString(const std::vector<uint8_t> &hash);
     std::string hexString() const;
@@ -42,8 +45,10 @@
 private:
     Hash(const std::string &path);
 
+    static Hash& getMutableHash(const std::string& path);
+
     const std::string mPath;
-    const std::vector<uint8_t> mHash;
+    std::vector<uint8_t> mHash;
 };
 
 }  // namespace android
diff --git a/main.cpp b/main.cpp
index 1b43e1e..dabbdaa 100644
--- a/main.cpp
+++ b/main.cpp
@@ -18,58 +18,277 @@
 #include "Coordinator.h"
 #include "Scope.h"
 
-#include <hidl-hash/Hash.h>
-#include <hidl-util/Formatter.h>
-#include <hidl-util/FQName.h>
-#include <hidl-util/StringHelper.h>
 #include <android-base/logging.h>
-#include <set>
+#include <hidl-hash/Hash.h>
+#include <hidl-util/FQName.h>
+#include <hidl-util/Formatter.h>
+#include <hidl-util/StringHelper.h>
 #include <stdio.h>
-#include <string>
+#include <sys/stat.h>
 #include <unistd.h>
+#include <iostream>
+#include <set>
+#include <string>
 #include <vector>
 
 using namespace android;
 
-struct OutputHandler {
-    std::string mKey;
-    std::string mDescription;
-    enum OutputMode {
-        NEEDS_DIR,
-        NEEDS_FILE,
-        NEEDS_SRC, // for changes inside the source tree itself
-        NOT_NEEDED
-    } mOutputMode;
-
-    const std::string& name() { return mKey; }
-    const std::string& description() { return mDescription; }
-
-    using ValidationFunction = std::function<bool(const FQName &, const std::string &language)>;
-    using GenerationFunction = std::function<status_t(const FQName &fqName,
-                                                      const char *hidl_gen,
-                                                      Coordinator *coordinator,
-                                                      const std::string &outputDir)>;
-
-    ValidationFunction validate;
-    GenerationFunction generate;
+enum class OutputMode {
+    NEEDS_DIR,   // -o output option expects a directory
+    NEEDS_FILE,  // -o output option expects a file
+    NEEDS_SRC,   // for changes inside the source tree itself
+    NOT_NEEDED   // does not create files
 };
 
-static bool generateForTest = false;
+enum class GenerationGranularity {
+    PER_PACKAGE,  // Files generated for each package
+    PER_FILE,     // Files generated for each hal file
+    PER_TYPE,     // Files generated for each hal file + each type in HAL files
+};
 
-static status_t generateSourcesForFile(
-        const FQName &fqName,
-        const char *,
-        Coordinator *coordinator,
-        const std::string &outputDir,
-        const std::string &lang) {
+// Represents a file that is generated by an -L option for an FQName
+struct FileGenerator {
+    using ShouldGenerateFunction = std::function<bool(const FQName& fqName)>;
+    using FileNameForFQName = std::function<std::string(const FQName& fqName)>;
+    using GenerationFunction = std::function<status_t(Formatter& out, const FQName& fqName,
+                                                      const Coordinator* coordinator)>;
+
+    ShouldGenerateFunction mShouldGenerateForFqName;  // If generate function applies to this target
+    FileNameForFQName mFileNameForFqName;             // Target -> filename
+    GenerationFunction mGenerationFunction;           // Function to generate output for file
+
+    std::string getFileName(const FQName& fqName) const {
+        return mFileNameForFqName ? mFileNameForFqName(fqName) : "";
+    }
+
+    status_t getOutputFile(const FQName& fqName, const Coordinator* coordinator,
+                           Coordinator::Location location, std::string* file) const {
+        if (!mShouldGenerateForFqName(fqName)) {
+            return OK;
+        }
+
+        return coordinator->getFilepath(fqName, location, getFileName(fqName), file);
+    }
+
+    status_t appendOutputFiles(const FQName& fqName, const Coordinator* coordinator,
+                               Coordinator::Location location,
+                               std::vector<std::string>* outputFiles) const {
+        if (location == Coordinator::Location::STANDARD_OUT) {
+            return OK;
+        }
+
+        if (mShouldGenerateForFqName(fqName)) {
+            std::string fileName;
+            status_t err = getOutputFile(fqName, coordinator, location, &fileName);
+            if (err != OK) return err;
+
+            if (!fileName.empty()) {
+                outputFiles->push_back(fileName);
+            }
+        }
+        return OK;
+    }
+
+    status_t generate(const FQName& fqName, const Coordinator* coordinator,
+                      Coordinator::Location location) const {
+        CHECK(mShouldGenerateForFqName != nullptr);
+        CHECK(mGenerationFunction != nullptr);
+
+        if (!mShouldGenerateForFqName(fqName)) {
+            return OK;
+        }
+
+        Formatter out = coordinator->getFormatter(fqName, location, getFileName(fqName));
+        if (!out.isValid()) {
+            return UNKNOWN_ERROR;
+        }
+
+        return mGenerationFunction(out, fqName, coordinator);
+    }
+
+    // Helper methods for filling out this struct
+    static bool generateForTypes(const FQName& fqName) {
+        const auto names = fqName.names();
+        return names.size() > 0 && names[0] == "types";
+    }
+    static bool generateForInterfaces(const FQName& fqName) { return !generateForTypes(fqName); }
+    static bool alwaysGenerate(const FQName&) { return true; }
+};
+
+// Represents a -L option, takes a fqName and generates files
+struct OutputHandler {
+    using ValidationFunction = std::function<bool(
+        const FQName& fqName, const Coordinator* coordinator, const std::string& language)>;
+
+    std::string mKey;                 // -L in Android.bp
+    std::string mDescription;         // for display in help menu
+    OutputMode mOutputMode;           // how this option interacts with -o
+    Coordinator::Location mLocation;  // how to compute location relative to the output directory
+    GenerationGranularity mGenerationGranularity;   // what to run generate function on
+    ValidationFunction mValidate;                   // if a given fqName is allowed for this option
+    std::vector<FileGenerator> mGenerateFunctions;  // run for each target at this granularity
+
+    const std::string& name() const { return mKey; }
+    const std::string& description() const { return mDescription; }
+
+    status_t generate(const FQName& fqName, const Coordinator* coordinator) const;
+    status_t validate(const FQName& fqName, const Coordinator* coordinator,
+                      const std::string& language) const {
+        return mValidate(fqName, coordinator, language);
+    }
+
+    status_t writeDepFile(const FQName& fqName, const Coordinator* coordinator) const;
+
+   private:
+    status_t appendTargets(const FQName& fqName, const Coordinator* coordinator,
+                           std::vector<FQName>* targets) const;
+    status_t appendOutputFiles(const FQName& fqName, const Coordinator* coordinator,
+                               std::vector<std::string>* outputFiles) const;
+};
+
+// Helper method for GenerationGranularity::PER_TYPE
+// IFoo -> IFoo, types.hal (containing Bar, Baz) -> types.Bar, types.Baz
+static status_t appendPerTypeTargets(const FQName& fqName, const Coordinator* coordinator,
+                                     std::vector<FQName>* exportedPackageInterfaces) {
     CHECK(fqName.isFullyQualified());
+    if (fqName.name() != "types") {
+        exportedPackageInterfaces->push_back(fqName);
+        return OK;
+    }
 
-    AST *ast;
+    AST* typesAST = coordinator->parse(fqName);
+    if (typesAST == nullptr) {
+        fprintf(stderr, "ERROR: Could not parse %s. Aborting.\n", fqName.string().c_str());
+        return UNKNOWN_ERROR;
+    }
+
+    std::vector<NamedType*> rootTypes = typesAST->getRootScope()->getSubTypes();
+    for (const NamedType* rootType : rootTypes) {
+        if (rootType->isTypeDef()) continue;
+
+        FQName rootTypeName(fqName.package(), fqName.version(), "types." + rootType->localName());
+        exportedPackageInterfaces->push_back(rootTypeName);
+    }
+    return OK;
+}
+
+status_t OutputHandler::appendTargets(const FQName& fqName, const Coordinator* coordinator,
+                                      std::vector<FQName>* targets) const {
+    switch (mGenerationGranularity) {
+        case GenerationGranularity::PER_PACKAGE: {
+            targets->push_back(fqName.getPackageAndVersion());
+        } break;
+        case GenerationGranularity::PER_FILE: {
+            if (fqName.isFullyQualified()) {
+                targets->push_back(fqName);
+                break;
+            }
+            status_t err = coordinator->appendPackageInterfacesToVector(fqName, targets);
+            if (err != OK) return err;
+        } break;
+        case GenerationGranularity::PER_TYPE: {
+            if (fqName.isFullyQualified()) {
+                status_t err = appendPerTypeTargets(fqName, coordinator, targets);
+                if (err != OK) return err;
+            }
+
+            std::vector<FQName> packageInterfaces;
+            status_t err = coordinator->appendPackageInterfacesToVector(fqName, &packageInterfaces);
+            if (err != OK) return err;
+            for (const FQName& packageInterface : packageInterfaces) {
+                err = appendPerTypeTargets(packageInterface, coordinator, targets);
+                if (err != OK) return err;
+            }
+        } break;
+        default:
+            CHECK(!"Should be here");
+    }
+
+    return OK;
+}
+
+status_t OutputHandler::generate(const FQName& fqName, const Coordinator* coordinator) const {
+    std::vector<FQName> targets;
+    status_t err = appendTargets(fqName, coordinator, &targets);
+    if (err != OK) return err;
+
+    for (const FQName& fqName : targets) {
+        for (const FileGenerator& file : mGenerateFunctions) {
+            status_t err = file.generate(fqName, coordinator, mLocation);
+            if (err != OK) return err;
+        }
+    }
+
+    return OK;
+}
+
+status_t OutputHandler::appendOutputFiles(const FQName& fqName, const Coordinator* coordinator,
+                                          std::vector<std::string>* outputFiles) const {
+    std::vector<FQName> targets;
+    status_t err = appendTargets(fqName, coordinator, &targets);
+    if (err != OK) return err;
+
+    for (const FQName& fqName : targets) {
+        for (const FileGenerator& file : mGenerateFunctions) {
+            err = file.appendOutputFiles(fqName, coordinator, mLocation, outputFiles);
+            if (err != OK) return err;
+        }
+    }
+
+    return OK;
+}
+
+status_t OutputHandler::writeDepFile(const FQName& fqName, const Coordinator* coordinator) const {
+    std::vector<std::string> outputFiles;
+    status_t err = appendOutputFiles(fqName, coordinator, &outputFiles);
+    if (err != OK) return err;
+
+    // No need for dep files
+    if (outputFiles.empty()) {
+        return OK;
+    }
+
+    // Depfiles in Android for genrules should be for the 'main file'. Because hidl-gen doesn't have
+    // a main file for most targets, we are just outputting a depfile for one single file only.
+    const std::string forFile = outputFiles[0];
+
+    return coordinator->writeDepFile(forFile);
+}
+
+// Use an AST function as a OutputHandler GenerationFunction
+static FileGenerator::GenerationFunction astGenerationFunction(void (AST::*generate)(Formatter&)
+                                                                   const = nullptr) {
+    return [generate](Formatter& out, const FQName& fqName,
+                      const Coordinator* coordinator) -> status_t {
+        AST* ast = coordinator->parse(fqName);
+        if (ast == nullptr) {
+            fprintf(stderr, "ERROR: Could not parse %s. Aborting.\n", fqName.string().c_str());
+            return UNKNOWN_ERROR;
+        }
+
+        if (generate == nullptr) return OK;  // just parsing AST
+        (ast->*generate)(out);
+
+        return OK;
+    };
+}
+
+// Common pattern: single file for package or standard out
+static FileGenerator singleFileGenerator(
+    const std::string& fileName, const FileGenerator::GenerationFunction& generationFunction) {
+    return {
+        FileGenerator::alwaysGenerate, [fileName](const FQName&) { return fileName; },
+        generationFunction,
+    };
+}
+
+static status_t generateJavaForPackage(Formatter& out, const FQName& fqName,
+                                       const Coordinator* coordinator) {
+    AST* ast;
     std::string limitToType;
 
+    // Required for legacy -Lmakefile files
     if (fqName.name().find("types.") == 0) {
-        CHECK(lang == "java");  // Already verified in validate().
-
         limitToType = fqName.name().substr(strlen("types."));
 
         FQName typesName = fqName.getTypesForPackage();
@@ -77,265 +296,49 @@
     } else {
         ast = coordinator->parse(fqName);
     }
-
-    if (ast == NULL) {
-        fprintf(stderr,
-                "ERROR: Could not parse %s. Aborting.\n",
-                fqName.string().c_str());
-
+    if (ast == nullptr) {
+        fprintf(stderr, "ERROR: Could not parse %s. Aborting.\n", fqName.string().c_str());
         return UNKNOWN_ERROR;
     }
+    ast->generateJava(out, limitToType);
+    return OK;
+};
 
-    if (lang == "check") {
-        return OK; // only parsing, not generating
-    }
-    if (lang == "c++") {
-        return ast->generateCpp(outputDir);
-    }
-    if (lang == "c++-headers") {
-        return ast->generateCppHeaders(outputDir);
-    }
-    if (lang == "c++-sources") {
-        return ast->generateCppSources(outputDir);
-    }
-    if (lang == "c++-impl") {
-        return ast->generateCppImpl(outputDir);
-    }
-    if (lang == "c++-impl-headers") {
-        return ast->generateStubImplHeader(outputDir);
-    }
-    if (lang == "c++-impl-sources") {
-        return ast->generateStubImplSource(outputDir);
-    }
-    if (lang == "java") {
-        return ast->generateJava(outputDir, limitToType);
-    }
-    if (lang == "vts") {
-        return ast->generateVts(outputDir);
-    }
-    // Unknown language.
-    return UNKNOWN_ERROR;
-}
-
-static status_t generateSourcesForPackage(
-        const FQName &packageFQName,
-        const char *hidl_gen,
-        Coordinator *coordinator,
-        const std::string &outputDir,
-        const std::string &lang) {
-    CHECK(packageFQName.isValid() &&
-        !packageFQName.isFullyQualified() &&
-        packageFQName.name().empty());
-
+static status_t dumpDefinedButUnreferencedTypeNames(const FQName& packageFQName,
+                                                    const Coordinator* coordinator) {
     std::vector<FQName> packageInterfaces;
+    status_t err = coordinator->appendPackageInterfacesToVector(packageFQName, &packageInterfaces);
+    if (err != OK) return err;
 
-    status_t err =
-        coordinator->appendPackageInterfacesToVector(packageFQName,
-                                                     &packageInterfaces);
+    std::set<FQName> unreferencedDefinitions;
+    std::set<FQName> unreferencedImports;
+    err = coordinator->addUnreferencedTypes(packageInterfaces, &unreferencedDefinitions,
+                                            &unreferencedImports);
+    if (err != OK) return err;
 
-    if (err != OK) {
-        return err;
+    for (const auto& fqName : unreferencedDefinitions) {
+        std::cerr
+            << "VERBOSE: DEFINED-BUT-NOT-REFERENCED "
+            << fqName.string()
+            << std::endl;
     }
 
-    for (const auto &fqName : packageInterfaces) {
-        err = generateSourcesForFile(
-                fqName, hidl_gen, coordinator, outputDir, lang);
-        if (err != OK) {
-            return err;
-        }
+    for (const auto& fqName : unreferencedImports) {
+        std::cerr
+            << "VERBOSE: IMPORTED-BUT-NOT-REFERENCED "
+            << fqName.string()
+            << std::endl;
     }
 
     return OK;
 }
 
-OutputHandler::GenerationFunction generationFunctionForFileOrPackage(const std::string &language) {
-    return [language](const FQName &fqName,
-              const char *hidl_gen, Coordinator *coordinator,
-              const std::string &outputDir) -> status_t {
-        if (fqName.isFullyQualified()) {
-                    return generateSourcesForFile(fqName,
-                                                  hidl_gen,
-                                                  coordinator,
-                                                  outputDir,
-                                                  language);
-        } else {
-                    return generateSourcesForPackage(fqName,
-                                                     hidl_gen,
-                                                     coordinator,
-                                                     outputDir,
-                                                     language);
-        }
-    };
-}
-
 static std::string makeLibraryName(const FQName &packageFQName) {
     return packageFQName.string();
 }
 
-static std::string makeJavaLibraryName(const FQName &packageFQName) {
-    std::string out;
-    out = packageFQName.package();
-    out += "-V";
-    out += packageFQName.version();
-    return out;
-}
-
-static void generatePackagePathsSection(
-        Formatter &out,
-        Coordinator *coordinator,
-        const FQName &packageFQName,
-        const std::set<FQName> &importedPackages,
-        bool forMakefiles = false) {
-    std::set<std::string> options{};
-    for (const auto &interface : importedPackages) {
-        options.insert(coordinator->getPackageRootOption(interface));
-    }
-    options.insert(coordinator->getPackageRootOption(packageFQName));
-    options.insert(coordinator->getPackageRootOption(gIBaseFqName));
-    for (const auto &option : options) {
-        out << "-r"
-            << option
-            << " ";
-        if (forMakefiles) {
-            out << "\\\n";
-        }
-    }
-}
-
-static void generateMakefileSectionForType(
-        Formatter &out,
-        Coordinator *coordinator,
-        const FQName &packageFQName,
-        const FQName &fqName,
-        const std::set<FQName> &importedPackages,
-        const char *typeName) {
-    out << "\n"
-        << "\n#"
-        << "\n# Build " << fqName.name() << ".hal";
-
-    if (typeName != nullptr) {
-        out << " (" << typeName << ")";
-    }
-
-    out << "\n#"
-        << "\nGEN := $(intermediates)/"
-        << coordinator->convertPackageRootToPath(packageFQName)
-        << coordinator->getPackagePath(packageFQName, true /* relative */,
-                true /* sanitized */);
-    if (typeName == nullptr) {
-        out << fqName.name() << ".java";
-    } else {
-        out << typeName << ".java";
-    }
-
-    out << "\n$(GEN): $(HIDL)";
-    out << "\n$(GEN): PRIVATE_HIDL := $(HIDL)";
-    out << "\n$(GEN): PRIVATE_DEPS := $(LOCAL_PATH)/"
-        << fqName.name() << ".hal";
-
-    {
-        AST *ast = coordinator->parse(fqName);
-        CHECK(ast != nullptr);
-        const std::set<FQName>& refs = ast->getImportedNames();
-        for (auto depFQName : refs) {
-            // If the package of depFQName is the same as this fqName's package,
-            // then add it explicitly as a .hal dependency within the same
-            // package.
-            if (fqName.package() == depFQName.package() &&
-                fqName.version() == depFQName.version()) {
-                    // PRIVATE_DEPS is not actually being used in the
-                    // auto-generated file, but is necessary if the build rule
-                    // ever needs to use the dependency information, since the
-                    // built-in Make variables are not supported in the Android
-                    // build system.
-                    out << "\n$(GEN): PRIVATE_DEPS += $(LOCAL_PATH)/"
-                        << depFQName.name() << ".hal";
-                    // This is the actual dependency.
-                    out << "\n$(GEN): $(LOCAL_PATH)/"
-                        << depFQName.name() << ".hal";
-            }
-        }
-    }
-
-    out << "\n$(GEN): PRIVATE_OUTPUT_DIR := $(intermediates)"
-        << "\n$(GEN): PRIVATE_CUSTOM_TOOL = \\";
-    out.indent();
-    out.indent();
-    out << "\n$(PRIVATE_HIDL) -o $(PRIVATE_OUTPUT_DIR) \\"
-        << "\n-Ljava \\\n";
-
-    generatePackagePathsSection(out, coordinator, packageFQName, importedPackages, true /* forJava */);
-
-    out << packageFQName.string()
-        << "::"
-        << fqName.name();
-
-    if (typeName != nullptr) {
-        out << "." << typeName;
-    }
-
-    out << "\n";
-
-    out.unindent();
-    out.unindent();
-
-    out << "\n$(GEN): $(LOCAL_PATH)/" << fqName.name() << ".hal";
-    out << "\n\t$(transform-generated-source)";
-    out << "\nLOCAL_GENERATED_SOURCES += $(GEN)";
-}
-
-static void generateMakefileSection(
-        Formatter &out,
-        Coordinator *coordinator,
-        const FQName &packageFQName,
-        const std::vector<FQName> &packageInterfaces,
-        const std::set<FQName> &importedPackages,
-        AST *typesAST) {
-    for (const auto &fqName : packageInterfaces) {
-        if (fqName.name() == "types") {
-            CHECK(typesAST != nullptr);
-
-            Scope* rootScope = typesAST->getRootScope();
-
-            std::vector<NamedType *> subTypes = rootScope->getSubTypes();
-            std::sort(
-                    subTypes.begin(),
-                    subTypes.end(),
-                    [](const NamedType *a, const NamedType *b) -> bool {
-                        return a->fqName() < b->fqName();
-                    });
-
-            for (const auto &type : subTypes) {
-                if (type->isTypeDef()) {
-                    continue;
-                }
-
-                generateMakefileSectionForType(
-                        out,
-                        coordinator,
-                        packageFQName,
-                        fqName,
-                        importedPackages,
-                        type->localName().c_str());
-            }
-
-            continue;
-        }
-
-        generateMakefileSectionForType(
-                out,
-                coordinator,
-                packageFQName,
-                fqName,
-                importedPackages,
-                nullptr /* typeName */);
-    }
-}
-
-static status_t isPackageJavaCompatible(
-        const FQName &packageFQName,
-        Coordinator *coordinator,
-        bool *compatible) {
+static status_t isPackageJavaCompatible(const FQName& packageFQName, const Coordinator* coordinator,
+                                        bool* compatible) {
     std::vector<FQName> todo;
     status_t err =
         coordinator->appendPackageInterfacesToVector(packageFQName, &todo);
@@ -395,6 +398,10 @@
 
 static bool packageNeedsJavaCode(
         const std::vector<FQName> &packageInterfaces, AST *typesAST) {
+    if (packageInterfaces.size() == 0) {
+        return false;
+    }
+
     // If there is more than just a types.hal file to this package we'll
     // definitely need to generate Java code.
     if (packageInterfaces.size() > 1
@@ -419,219 +426,8 @@
     return false;
 }
 
-static void generateMakefileSectionForJavaConstants(
-        Formatter &out,
-        Coordinator *coordinator,
-        const FQName &packageFQName,
-        const std::vector<FQName> &packageInterfaces,
-        const std::set<FQName> &importedPackages) {
-    out << "\n#"
-        << "\nGEN := $(intermediates)/"
-        << coordinator->convertPackageRootToPath(packageFQName)
-        << coordinator->getPackagePath(packageFQName, true /* relative */, true /* sanitized */)
-        << "Constants.java";
-
-    out << "\n$(GEN): $(HIDL)\n";
-    for (const auto &iface : packageInterfaces) {
-        out << "$(GEN): $(LOCAL_PATH)/" << iface.name() << ".hal\n";
-    }
-    out << "\n$(GEN): PRIVATE_HIDL := $(HIDL)";
-    out << "\n$(GEN): PRIVATE_OUTPUT_DIR := $(intermediates)"
-        << "\n$(GEN): PRIVATE_CUSTOM_TOOL = \\";
-    out.indent();
-    out.indent();
-    out << "\n$(PRIVATE_HIDL) -o $(PRIVATE_OUTPUT_DIR) \\"
-        << "\n-Ljava-constants \\\n";
-
-    generatePackagePathsSection(out, coordinator, packageFQName, importedPackages, true /* forJava */);
-
-    out << packageFQName.string();
-    out << "\n";
-
-    out.unindent();
-    out.unindent();
-
-    out << "\n$(GEN):";
-    out << "\n\t$(transform-generated-source)";
-    out << "\nLOCAL_GENERATED_SOURCES += $(GEN)";
-}
-
-static status_t generateMakefileForPackage(
-        const FQName &packageFQName,
-        const char *hidl_gen,
-        Coordinator *coordinator,
-        const std::string &outputPath) {
-
-    CHECK(packageFQName.isValid() &&
-          !packageFQName.isFullyQualified() &&
-          packageFQName.name().empty());
-
-    std::vector<FQName> packageInterfaces;
-
-    status_t err =
-        coordinator->appendPackageInterfacesToVector(packageFQName,
-                                                     &packageInterfaces);
-
-    if (err != OK) {
-        return err;
-    }
-
-    std::set<FQName> importedPackages;
-    AST *typesAST = nullptr;
-    std::vector<const Type *> exportedTypes;
-
-    for (const auto &fqName : packageInterfaces) {
-        AST *ast = coordinator->parse(fqName);
-
-        if (ast == NULL) {
-            fprintf(stderr,
-                    "ERROR: Could not parse %s. Aborting.\n",
-                    fqName.string().c_str());
-
-            return UNKNOWN_ERROR;
-        }
-
-        if (fqName.name() == "types") {
-            typesAST = ast;
-        }
-
-        ast->getImportedPackagesHierarchy(&importedPackages);
-        ast->appendToExportedTypesVector(&exportedTypes);
-    }
-
-    bool packageIsJavaCompatible;
-    err = isPackageJavaCompatible(
-            packageFQName, coordinator, &packageIsJavaCompatible);
-
-    if (err != OK) {
-        return err;
-    }
-
-    bool haveJavaConstants = !exportedTypes.empty();
-
-    if (!packageIsJavaCompatible && !haveJavaConstants) {
-        // TODO(b/33420795)
-        fprintf(stderr,
-                "WARNING: %s is not java compatible. No java makefile created.\n",
-                packageFQName.string().c_str());
-        return OK;
-    }
-
-    if (!packageNeedsJavaCode(packageInterfaces, typesAST)) {
-        return OK;
-    }
-
-    std::string path = outputPath;
-    path.append(coordinator->getPackagePath(packageFQName, false /* relative */));
-    path.append("Android.mk");
-
-    CHECK(Coordinator::MakeParentHierarchy(path));
-    FILE *file = fopen(path.c_str(), "w");
-
-    if (file == NULL) {
-        return -errno;
-    }
-
-    const std::string libraryName = makeJavaLibraryName(packageFQName);
-
-    Formatter out(file);
-
-    out << "# This file is autogenerated by hidl-gen. Do not edit manually.\n\n";
-    out << "LOCAL_PATH := $(call my-dir)\n";
-
-    enum LibraryStyle {
-        LIBRARY_STYLE_REGULAR,
-        LIBRARY_STYLE_STATIC,
-        LIBRARY_STYLE_END,
-    };
-
-    for (int style = LIBRARY_STYLE_REGULAR;
-            (packageIsJavaCompatible && style != LIBRARY_STYLE_END);
-            ++style) {
-        const std::string staticSuffix =
-            (style == LIBRARY_STYLE_STATIC) ? "-static" : "";
-
-        out << "\n"
-            << "########################################"
-            << "########################################\n\n";
-
-        out << "include $(CLEAR_VARS)\n"
-            << "LOCAL_MODULE := "
-            << libraryName
-            << "-java"
-            << staticSuffix
-            << "\nLOCAL_MODULE_CLASS := JAVA_LIBRARIES\n\n"
-            << "intermediates := $(call local-generated-sources-dir, COMMON)"
-            << "\n\n"
-            << "HIDL := $(HOST_OUT_EXECUTABLES)/"
-            << hidl_gen
-            << "$(HOST_EXECUTABLE_SUFFIX)";
-
-        if (!importedPackages.empty()) {
-            out << "\n"
-                << "\nLOCAL_"
-                << ((style == LIBRARY_STYLE_STATIC) ? "STATIC_" : "")
-                << "JAVA_LIBRARIES := \\";
-
-            out.indent();
-            for (const auto &importedPackage : importedPackages) {
-                out << "\n"
-                    << makeJavaLibraryName(importedPackage)
-                    << "-java"
-                    << staticSuffix
-                    << " \\";
-            }
-            out << "\n";
-            out.unindent();
-        }
-
-        generateMakefileSection(
-                out,
-                coordinator,
-                packageFQName,
-                packageInterfaces,
-                importedPackages,
-                typesAST);
-
-        out << "\ninclude $(BUILD_"
-            << ((style == LIBRARY_STYLE_STATIC) ? "STATIC_" : "")
-            << "JAVA_LIBRARY)\n\n";
-    }
-
-    if (haveJavaConstants) {
-        out << "\n"
-            << "########################################"
-            << "########################################\n\n";
-
-        out << "include $(CLEAR_VARS)\n"
-            << "LOCAL_MODULE := "
-            << libraryName
-            << "-java-constants"
-            << "\nLOCAL_MODULE_CLASS := JAVA_LIBRARIES\n\n"
-            << "intermediates := $(call local-generated-sources-dir, COMMON)"
-            << "\n\n"
-            << "HIDL := $(HOST_OUT_EXECUTABLES)/"
-            << hidl_gen
-            << "$(HOST_EXECUTABLE_SUFFIX)";
-
-        generateMakefileSectionForJavaConstants(
-                out, coordinator, packageFQName, packageInterfaces, importedPackages);
-
-        out << "\n# Avoid dependency cycle of framework.jar -> this-library "
-            << "-> framework.jar\n"
-            << "LOCAL_NO_STANDARD_LIBRARIES := true\n"
-            << "LOCAL_JAVA_LIBRARIES := core-oj\n\n"
-            << "include $(BUILD_STATIC_JAVA_LIBRARY)\n\n";
-    }
-
-    out << "\n\n"
-        << "include $(call all-makefiles-under,$(LOCAL_PATH))\n";
-
-    return OK;
-}
-
-bool validateIsPackage(
-        const FQName &fqName, const std::string & /* language */) {
+bool validateIsPackage(const FQName& fqName, const Coordinator*,
+                       const std::string& /* language */) {
     if (fqName.package().empty()) {
         fprintf(stderr, "ERROR: Expecting package name\n");
         return false;
@@ -652,17 +448,19 @@
 }
 
 bool isHidlTransportPackage(const FQName& fqName) {
-    return fqName.package() == gIBasePackageFqName.string() ||
-           fqName.package() == gIManagerPackageFqName.string();
+    return fqName.package() == gIBaseFqName.package() ||
+           fqName.package() == gIManagerFqName.package();
 }
 
 bool isSystemProcessSupportedPackage(const FQName& fqName) {
     // Technically, so is hidl IBase + IServiceManager, but
     // these are part of libhidltransport.
-    return fqName.string() == "android.hardware.graphics.allocator@2.0" ||
-           fqName.string() == "android.hardware.graphics.common@1.0" ||
+    return fqName.string() == "android.hardware.graphics.common@1.0" ||
+           fqName.string() == "android.hardware.graphics.common@1.1" ||
            fqName.string() == "android.hardware.graphics.mapper@2.0" ||
+           fqName.string() == "android.hardware.graphics.mapper@2.1" ||
            fqName.string() == "android.hardware.renderscript@1.0" ||
+           fqName.string() == "android.hidl.memory.token@1.0" ||
            fqName.string() == "android.hidl.memory@1.0";
 }
 
@@ -673,155 +471,89 @@
            package.inPackage("android.hardware");
 }
 
-static void generateAndroidBpGenSection(
-        Formatter &out,
-        const FQName &packageFQName,
-        const char *hidl_gen,
-        Coordinator *coordinator,
-        const std::string &halFilegroupName,
-        const std::string &genName,
-        const char *language,
-        const std::vector<FQName> &packageInterfaces,
-        const std::set<FQName> &importedPackages,
-        const std::function<void(Formatter&, const FQName)> outputFn) {
+// TODO(b/69862859): remove special case
+status_t isTestPackage(const FQName& fqName, const Coordinator* coordinator, bool* isTestPackage) {
+    const auto fileExists = [](const std::string& file) {
+        struct stat buf;
+        return stat(file.c_str(), &buf) == 0;
+    };
 
-    out << "genrule {\n";
-    out.indent();
-    out << "name: \"" << genName << "\",\n"
-        << "tools: [\"" << hidl_gen << "\"],\n";
+    std::string path;
+    status_t err = coordinator->getFilepath(fqName, Coordinator::Location::PACKAGE_ROOT,
+                                            ".hidl_for_test", &path);
+    if (err != OK) return err;
 
-    out << "cmd: \"$(location " << hidl_gen << ") -o $(genDir)"
-        << " -L" << language << " ";
+    const bool exists = fileExists(path);
 
-    generatePackagePathsSection(out, coordinator, packageFQName, importedPackages);
-
-    out << packageFQName.string() << "\",\n";
-
-    out << "srcs: [\n";
-    out.indent();
-    out << "\":" << halFilegroupName << "\",\n";
-    out.unindent();
-    out << "],\n";
-
-    out << "out: [\n";
-    out.indent();
-    for (const auto &fqName : packageInterfaces) {
-        outputFn(out, fqName);
+    if (exists) {
+        coordinator->onFileAccess(path, "r");
     }
-    out.unindent();
-    out << "],\n";
 
-    out.unindent();
-    out << "}\n\n";
+    *isTestPackage = exists;
+    return OK;
 }
 
-static void generateAndroidBpDependencyList(
-        Formatter &out,
-        const std::set<FQName> &importedPackagesHierarchy,
-        bool generateVendor) {
-    for (const auto &importedPackage : importedPackagesHierarchy) {
-        if (isHidlTransportPackage(importedPackage)) {
+static status_t generateAdapterMainSource(Formatter& out, const FQName& packageFQName,
+                                          const Coordinator* coordinator) {
+    std::vector<FQName> packageInterfaces;
+    status_t err =
+        coordinator->appendPackageInterfacesToVector(packageFQName,
+                                                     &packageInterfaces);
+    if (err != OK) {
+        return err;
+    }
+
+    out << "#include <hidladapter/HidlBinderAdapter.h>\n";
+
+    for (auto &interface : packageInterfaces) {
+        if (interface.name() == "types") {
             continue;
         }
-
-        out << "\"" << makeLibraryName(importedPackage);
-        if (generateVendor && !isSystemPackage(importedPackage)) {
-            out << "_vendor";
-        }
-        out << "\",\n";
+        AST::generateCppPackageInclude(out, interface, interface.getInterfaceAdapterName());
     }
+
+    out << "int main(int argc, char** argv) ";
+    out.block([&] {
+        out << "return ::android::hardware::adapterMain<\n";
+        out.indent();
+        for (auto &interface : packageInterfaces) {
+            if (interface.name() == "types") {
+                continue;
+            }
+            out << interface.getInterfaceAdapterFqName().cppName();
+
+            if (&interface != &packageInterfaces.back()) {
+                out << ",\n";
+            }
+        }
+        out << ">(\"" << packageFQName.string() << "\", argc, argv);\n";
+        out.unindent();
+    }).endl();
+    return OK;
 }
 
-static void generateAndroidBpLibSection(
-        Formatter &out,
-        bool generateVendor,
-        const FQName &packageFQName,
-        const std::string &libraryName,
-        const std::string &genSourceName,
-        const std::string &genHeaderName,
-        const std::set<FQName> &importedPackagesHierarchy) {
-
-    // C++ library definition
-    out << "cc_library {\n";
-    out.indent();
-    out << "name: \"" << libraryName << (generateVendor ? "_vendor" : "") << "\",\n"
-        << "defaults: [\"hidl-module-defaults\"],\n"
-        << "generated_sources: [\"" << genSourceName << "\"],\n"
-        << "generated_headers: [\"" << genHeaderName << "\"],\n"
-        << "export_generated_headers: [\"" << genHeaderName << "\"],\n";
-
-    if (generateVendor) {
-        out << "vendor: true,\n";
-    } else {
-        out << "vendor_available: true,\n";
-        if (!generateForTest) {
-            out << "vndk: ";
-            out.block([&]() {
-                out << "enabled: true,\n";
-                if (isSystemProcessSupportedPackage(packageFQName)) {
-                    out << "support_system_process: true,\n";
-                }
-            }) << ",\n";
-        }
-    }
-    out << "shared_libs: [\n";
-
-    out.indent();
-    out << "\"libhidlbase\",\n"
-        << "\"libhidltransport\",\n"
-        << "\"libhwbinder\",\n"
-        << "\"liblog\",\n"
-        << "\"libutils\",\n"
-        << "\"libcutils\",\n";
-    generateAndroidBpDependencyList(out, importedPackagesHierarchy, generateVendor);
-    out.unindent();
-
-    out << "],\n";
-
-    out << "export_shared_lib_headers: [\n";
-    out.indent();
-    out << "\"libhidlbase\",\n"
-        << "\"libhidltransport\",\n"
-        << "\"libhwbinder\",\n"
-        << "\"libutils\",\n";
-    generateAndroidBpDependencyList(out, importedPackagesHierarchy, generateVendor);
-    out.unindent();
-    out << "],\n";
-    out.unindent();
-
-    out << "}\n";
-}
-
-static status_t generateAndroidBpForPackage(
-        const FQName &packageFQName,
-        const char *hidl_gen,
-        Coordinator *coordinator,
-        const std::string &outputPath) {
-
-    CHECK(packageFQName.isValid() &&
-          !packageFQName.isFullyQualified() &&
+static status_t generateAndroidBpForPackage(Formatter& out, const FQName& packageFQName,
+                                            const Coordinator* coordinator) {
+    CHECK(packageFQName.isValid() && !packageFQName.isFullyQualified() &&
           packageFQName.name().empty());
 
     std::vector<FQName> packageInterfaces;
 
-    status_t err =
-        coordinator->appendPackageInterfacesToVector(packageFQName,
-                                                     &packageInterfaces);
+    status_t err = coordinator->appendPackageInterfacesToVector(packageFQName, &packageInterfaces);
 
     if (err != OK) {
         return err;
     }
 
     std::set<FQName> importedPackagesHierarchy;
-    AST *typesAST = nullptr;
+    std::vector<const Type *> exportedTypes;
+    AST* typesAST = nullptr;
 
-    for (const auto &fqName : packageInterfaces) {
-        AST *ast = coordinator->parse(fqName);
+    for (const auto& fqName : packageInterfaces) {
+        AST* ast = coordinator->parse(fqName);
 
         if (ast == NULL) {
-            fprintf(stderr,
-                    "ERROR: Could not parse %s. Aborting.\n",
-                    fqName.string().c_str());
+            fprintf(stderr, "ERROR: Could not parse %s. Aborting.\n", fqName.string().c_str());
 
             return UNKNOWN_ERROR;
         }
@@ -831,134 +563,93 @@
         }
 
         ast->getImportedPackagesHierarchy(&importedPackagesHierarchy);
+        ast->appendToExportedTypesVector(&exportedTypes);
     }
 
-    std::string path = outputPath;
-    path.append(coordinator->getPackagePath(packageFQName, false /* relative */));
-    path.append("Android.bp");
+    bool needsJavaCode = packageNeedsJavaCode(packageInterfaces, typesAST);
 
-    CHECK(Coordinator::MakeParentHierarchy(path));
-    FILE *file = fopen(path.c_str(), "w");
+    bool genJavaConstants = needsJavaCode && !exportedTypes.empty();
 
-    if (file == NULL) {
-        return -errno;
-    }
+    bool isJavaCompatible;
+    err = isPackageJavaCompatible(packageFQName, coordinator, &isJavaCompatible);
+    if (err != OK) return err;
+    bool genJavaLibrary = needsJavaCode && isJavaCompatible;
 
-    const std::string libraryName = makeLibraryName(packageFQName);
-    const std::string halFilegroupName = libraryName + "_hal";
-    const std::string genSourceName = libraryName + "_genc++";
-    const std::string genHeaderName = libraryName + "_genc++_headers";
-    const std::string pathPrefix =
-        coordinator->convertPackageRootToPath(packageFQName) +
-        coordinator->getPackagePath(packageFQName, true /* relative */);
+    bool generateForTest;
+    err = isTestPackage(packageFQName, coordinator, &generateForTest);
+    if (err != OK) return err;
 
-    Formatter out(file);
+    bool isVndk = !generateForTest && isSystemPackage(packageFQName);
+    bool isVndkSp = isVndk && isSystemProcessSupportedPackage(packageFQName);
 
-    out << "// This file is autogenerated by hidl-gen. Do not edit manually.\n\n";
+    std::string packageRoot;
+    err = coordinator->getPackageRoot(packageFQName, &packageRoot);
+    if (err != OK) return err;
 
-    // Rule to generate .hal filegroup
-    out << "filegroup {\n";
-    out.indent();
-    out << "name: \"" << halFilegroupName << "\",\n";
-    out << "srcs: [\n";
-    out.indent();
-    for (const auto &fqName : packageInterfaces) {
-      out << "\"" << fqName.name() << ".hal\",\n";
-    }
-    out.unindent();
-    out << "],\n";
-    out.unindent();
-    out << "}\n\n";
+    out << "// This file is autogenerated by hidl-gen -Landroidbp.\n\n";
 
-    // Rule to generate the C++ source files
-    generateAndroidBpGenSection(
-            out,
-            packageFQName,
-            hidl_gen,
-            coordinator,
-            halFilegroupName,
-            genSourceName,
-            "c++-sources",
-            packageInterfaces,
-            importedPackagesHierarchy,
-            [&pathPrefix](Formatter &out, const FQName &fqName) {
-                if (fqName.name() == "types") {
-                    out << "\"" << pathPrefix << "types.cpp\",\n";
-                } else {
-                    out << "\"" << pathPrefix << fqName.name().substr(1) << "All.cpp\",\n";
-                }
-            });
-
-    // Rule to generate the C++ header files
-    generateAndroidBpGenSection(
-            out,
-            packageFQName,
-            hidl_gen,
-            coordinator,
-            halFilegroupName,
-            genHeaderName,
-            "c++-headers",
-            packageInterfaces,
-            importedPackagesHierarchy,
-            [&pathPrefix](Formatter &out, const FQName &fqName) {
-                out << "\"" << pathPrefix << fqName.name() << ".h\",\n";
-                if (fqName.name() != "types") {
-                    out << "\"" << pathPrefix << fqName.getInterfaceHwName() << ".h\",\n";
-                    out << "\"" << pathPrefix << fqName.getInterfaceStubName() << ".h\",\n";
-                    out << "\"" << pathPrefix << fqName.getInterfaceProxyName() << ".h\",\n";
-                    out << "\"" << pathPrefix << fqName.getInterfacePassthroughName() << ".h\",\n";
-                } else {
-                    out << "\"" << pathPrefix << "hwtypes.h\",\n";
-                }
-            });
-
-    if (isHidlTransportPackage(packageFQName)) {
-        out << "// " << packageFQName.string() << " is exported from libhidltransport\n";
-    } else {
-        generateAndroidBpLibSection(
-            out,
-            false /* generateVendor */,
-            packageFQName,
-            libraryName,
-            genSourceName,
-            genHeaderName,
-            importedPackagesHierarchy);
-
-        // TODO(b/35813011): make all libraries vendor_available
-        // Explicitly create '_vendor' copies of libraries so that
-        // vendor code can link against the extensions. When this is
-        // used, framework code should link against vendor.awesome.foo@1.0
-        // and code on the vendor image should link against
-        // vendor.awesome.foo@1.0_vendor. For libraries with the below extensions,
-        // they will be available even on the generic system image.
-        // Because of this, they should always be referenced without the
-        // '_vendor' name suffix.
-        if (!isSystemPackage(packageFQName)) {
-
-            // Note, not using cc_defaults here since it's already not used and
-            // because generating this libraries will be removed when the VNDK
-            // is enabled (done by the build system itself).
-            out.endl();
-            generateAndroidBpLibSection(
-                out,
-                true /* generateVendor */,
-                packageFQName,
-                libraryName,
-                genSourceName,
-                genHeaderName,
-                importedPackagesHierarchy);
+    out << "hidl_interface ";
+    out.block([&] {
+        out << "name: \"" << makeLibraryName(packageFQName) << "\",\n";
+        if (!coordinator->getOwner().empty()) {
+            out << "owner: \"" << coordinator->getOwner() << "\",\n";
         }
-    }
+        out << "root: \"" << packageRoot << "\",\n";
+        if (isHidlTransportPackage(packageFQName)) {
+            out << "core_interface: true,\n";
+        }
+        if (isVndk) {
+            out << "vndk: ";
+            out.block([&]() {
+                out << "enabled: true,\n";
+                if (isVndkSp) {
+                    out << "support_system_process: true,\n";
+                }
+            }) << ",\n";
+        }
+        (out << "srcs: [\n").indent([&] {
+           for (const auto& fqName : packageInterfaces) {
+               out << "\"" << fqName.name() << ".hal\",\n";
+           }
+        }) << "],\n";
+        if (!importedPackagesHierarchy.empty()) {
+            (out << "interfaces: [\n").indent([&] {
+               for (const auto& fqName : importedPackagesHierarchy) {
+                   out << "\"" << fqName.string() << "\",\n";
+               }
+            }) << "],\n";
+        }
+        if (typesAST != nullptr) {
+            (out << "types: [\n").indent([&] {
+                std::vector<NamedType *> subTypes = typesAST->getRootScope()->getSubTypes();
+                std::sort(
+                        subTypes.begin(),
+                        subTypes.end(),
+                        [](const NamedType *a, const NamedType *b) -> bool {
+                            return a->fqName() < b->fqName();
+                        });
+
+                for (const auto &type : subTypes) {
+                    if (type->isTypeDef()) {
+                        continue;
+                    }
+
+                    out << "\"" << type->localName() << "\",\n";
+                }
+            }) << "],\n";
+        }
+        // Explicity call this out for developers.
+        out << "gen_java: " << (genJavaLibrary ? "true" : "false") << ",\n";
+        if (genJavaConstants) {
+            out << "gen_java_constants: true,\n";
+        }
+   }).endl().endl();
 
     return OK;
 }
 
-static status_t generateAndroidBpImplForPackage(
-        const FQName &packageFQName,
-        const char *,
-        Coordinator *coordinator,
-        const std::string &outputDir) {
-
+static status_t generateAndroidBpImplForPackage(Formatter& out, const FQName& packageFQName,
+                                                const Coordinator* coordinator) {
     const std::string libraryName = makeLibraryName(packageFQName) + "-impl";
 
     std::vector<FQName> packageInterfaces;
@@ -987,23 +678,28 @@
         ast->getImportedPackages(&importedPackages);
     }
 
-    std::string path = outputDir + "Android.bp";
-
-    CHECK(Coordinator::MakeParentHierarchy(path));
-    FILE *file = fopen(path.c_str(), "w");
-
-    if (file == NULL) {
-        return -errno;
-    }
-
-    Formatter out(file);
-
     out << "cc_library_shared {\n";
     out.indent([&] {
-        out << "name: \"" << libraryName << "\",\n"
-            << "relative_install_path: \"hw\",\n"
-            << "proprietary: true,\n"
-            << "srcs: [\n";
+        out << "// FIXME: this should only be -impl for a passthrough hal.\n"
+            << "// In most cases, to convert this to a binderized implementation, you should:\n"
+            << "// - change '-impl' to '-service' here and make it a cc_binary instead of a\n"
+            << "//   cc_library_shared.\n"
+            << "// - add a *.rc file for this module.\n"
+            << "// - delete HIDL_FETCH_I* functions.\n"
+            << "// - call configureRpcThreadpool and registerAsService on the instance.\n"
+            << "// You may also want to append '-impl/-service' with a specific identifier like\n"
+            << "// '-vendor' or '-<hardware identifier>' etc to distinguish it.\n";
+        out << "name: \"" << libraryName << "\",\n";
+        if (!coordinator->getOwner().empty()) {
+            out << "owner: \"" << coordinator->getOwner() << "\",\n";
+        }
+        out << "relative_install_path: \"hw\",\n";
+        if (coordinator->getOwner().empty()) {
+            out << "// FIXME: this should be 'vendor: true' for modules that will eventually be\n"
+                   "// on AOSP.\n";
+        }
+        out << "proprietary: true,\n";
+        out << "srcs: [\n";
         out.indent([&] {
             for (const auto &fqName : packageInterfaces) {
                 if (fqName.name() == "types") {
@@ -1035,8 +731,8 @@
     return OK;
 }
 
-bool validateForSource(
-        const FQName &fqName, const std::string &language) {
+bool validateForSource(const FQName& fqName, const Coordinator* coordinator,
+                       const std::string& language) {
     if (fqName.package().empty()) {
         fprintf(stderr, "ERROR: Expecting package name\n");
         return false;
@@ -1066,14 +762,29 @@
         return true;
     }
 
+    if (language == "java") {
+        bool isJavaCompatible;
+        status_t err = isPackageJavaCompatible(fqName, coordinator, &isJavaCompatible);
+        if (err != OK) return false;
+
+        if (!isJavaCompatible) {
+            fprintf(stderr,
+                    "ERROR: %s is not Java compatible. The Java backend"
+                    " does NOT support union types nor native handles. "
+                    "In addition, vectors of arrays are limited to at most "
+                    "one-dimensional arrays and vectors of {vectors,interfaces} are"
+                    " not supported.\n",
+                    fqName.string().c_str());
+            return false;
+        }
+    }
+
     return true;
 }
 
-OutputHandler::GenerationFunction generateExportHeaderForPackage(bool forJava) {
-    return [forJava](const FQName &packageFQName,
-                     const char * /* hidl_gen */,
-                     Coordinator *coordinator,
-                     const std::string &outputPath) -> status_t {
+FileGenerator::GenerationFunction generateExportHeaderForPackage(bool forJava) {
+    return [forJava](Formatter& out, const FQName& packageFQName,
+                     const Coordinator* coordinator) -> status_t {
         CHECK(packageFQName.isValid()
                 && !packageFQName.package().empty()
                 && !packageFQName.version().empty()
@@ -1108,29 +819,18 @@
             return OK;
         }
 
-        std::string path = outputPath;
-
-        if (forJava) {
-            path.append(coordinator->convertPackageRootToPath(packageFQName));
-
-            path.append(coordinator->getPackagePath(
-                        packageFQName, true /* relative */, true /* sanitized */));
-
-            path.append("Constants.java");
+        if (!out.isValid()) {
+            return UNKNOWN_ERROR;
         }
 
-        CHECK(Coordinator::MakeParentHierarchy(path));
-        FILE *file = fopen(path.c_str(), "w");
-
-        if (file == nullptr) {
-            return -errno;
-        }
-
-        Formatter out(file);
+        std::string packagePath;
+        err = coordinator->getPackagePath(packageFQName, false /* relative */,
+                                          false /* sanitized */, &packagePath);
+        if (err != OK) return err;
 
         out << "// This file is autogenerated by hidl-gen. Do not edit manually.\n"
             << "// Source: " << packageFQName.string() << "\n"
-            << "// Root: " << coordinator->getPackageRootOption(packageFQName) << "\n\n";
+            << "// Location: " << packagePath << "\n\n";
 
         std::string guard;
         if (forJava) {
@@ -1167,164 +867,336 @@
     };
 }
 
-static status_t generateHashOutput(const FQName &fqName,
-        const char* /*hidl_gen*/,
-        Coordinator *coordinator,
-        const std::string & /*outputDir*/) {
+static status_t generateHashOutput(Formatter& out, const FQName& fqName,
+                                   const Coordinator* coordinator) {
+    CHECK(fqName.isFullyQualified());
 
-    status_t err;
-    std::vector<FQName> packageInterfaces;
+    AST* ast = coordinator->parse(fqName, {} /* parsed */,
+                                  Coordinator::Enforce::NO_HASH /* enforcement */);
 
-    if (fqName.isFullyQualified()) {
-        packageInterfaces = {fqName};
-    } else {
-        err = coordinator->appendPackageInterfacesToVector(
-                fqName, &packageInterfaces);
-        if (err != OK) {
-            return err;
-        }
+    if (ast == NULL) {
+        fprintf(stderr, "ERROR: Could not parse %s. Aborting.\n", fqName.string().c_str());
+
+        return UNKNOWN_ERROR;
     }
 
-    for (const auto &currentFqName : packageInterfaces) {
-        AST* ast = coordinator->parse(currentFqName, {} /* parsed */,
-                                      Coordinator::Enforce::NO_HASH /* enforcement */);
-
-        if (ast == NULL) {
-            fprintf(stderr,
-                    "ERROR: Could not parse %s. Aborting.\n",
-                    currentFqName.string().c_str());
-
-            return UNKNOWN_ERROR;
-        }
-
-        printf("%s %s\n",
-                Hash::getHash(ast->getFilename()).hexString().c_str(),
-                currentFqName.string().c_str());
-    }
+    out << Hash::getHash(ast->getFilename()).hexString() << " " << fqName.string() << "\n";
 
     return OK;
 }
 
-static std::vector<OutputHandler> formats = {
-    {"check",
-     "Parses the interface to see if valid but doesn't write any files.",
-     OutputHandler::NOT_NEEDED /* mOutputMode */,
-     validateForSource,
-     generationFunctionForFileOrPackage("check")
-    },
+template <typename T>
+std::vector<T> operator+(const std::vector<T>& lhs, const std::vector<T>& rhs) {
+    std::vector<T> ret;
+    ret.reserve(lhs.size() + rhs.size());
+    ret.insert(ret.begin(), lhs.begin(), lhs.end());
+    ret.insert(ret.end(), rhs.begin(), rhs.end());
+    return ret;
+}
 
-    {"c++",
-     "(internal) (deprecated) Generates C++ interface files for talking to HIDL interfaces.",
-     OutputHandler::NEEDS_DIR /* mOutputMode */,
-     validateForSource,
-     generationFunctionForFileOrPackage("c++")
+// clang-format off
+static const std::vector<FileGenerator> kCppHeaderFormats = {
+    {
+        FileGenerator::alwaysGenerate,
+        [](const FQName& fqName) { return fqName.name() + ".h"; },
+        astGenerationFunction(&AST::generateInterfaceHeader),
     },
-
-    {"c++-headers",
-     "(internal) Generates C++ headers for interface files for talking to HIDL interfaces.",
-     OutputHandler::NEEDS_DIR /* mOutputMode */,
-     validateForSource,
-     generationFunctionForFileOrPackage("c++-headers")
+    {
+        FileGenerator::alwaysGenerate,
+        [](const FQName& fqName) {
+            return fqName.isInterfaceName() ? fqName.getInterfaceHwName() + ".h" : "hwtypes.h";
+        },
+        astGenerationFunction(&AST::generateHwBinderHeader),
     },
-
-    {"c++-sources",
-     "(internal) Generates C++ sources for interface files for talking to HIDL interfaces.",
-     OutputHandler::NEEDS_DIR /* mOutputMode */,
-     validateForSource,
-     generationFunctionForFileOrPackage("c++-sources")
+    {
+        FileGenerator::generateForInterfaces,
+        [](const FQName& fqName) { return fqName.getInterfaceStubName() + ".h"; },
+        astGenerationFunction(&AST::generateStubHeader),
     },
-
-    {"export-header",
-     "Generates a header file from @export enumerations to help maintain legacy code.",
-     OutputHandler::NEEDS_FILE /* mOutputMode */,
-     validateIsPackage,
-     generateExportHeaderForPackage(false /* forJava */)
+    {
+        FileGenerator::generateForInterfaces,
+        [](const FQName& fqName) { return fqName.getInterfaceProxyName() + ".h"; },
+        astGenerationFunction(&AST::generateProxyHeader),
     },
-
-    {"c++-impl",
-     "Generates boilerplate implementation of a hidl interface in C++ (for convenience).",
-     OutputHandler::NEEDS_DIR /* mOutputMode */,
-     validateForSource,
-     generationFunctionForFileOrPackage("c++-impl")
-    },
-    {"c++-impl-headers",
-     "c++-impl but headers only",
-     OutputHandler::NEEDS_DIR /* mOutputMode */,
-     validateForSource,
-     generationFunctionForFileOrPackage("c++-impl-headers")
-    },
-    {"c++-impl-sources",
-     "c++-impl but sources only",
-     OutputHandler::NEEDS_DIR /* mOutputMode */,
-     validateForSource,
-     generationFunctionForFileOrPackage("c++-impl-sources")
-    },
-
-    {"java",
-     "(internal) Generates Java library for talking to HIDL interfaces in Java.",
-     OutputHandler::NEEDS_DIR /* mOutputMode */,
-     validateForSource,
-     generationFunctionForFileOrPackage("java")
-    },
-
-    {"java-constants",
-     "(internal) Like export-header but for Java (always created by -Lmakefile if @export exists).",
-     OutputHandler::NEEDS_DIR /* mOutputMode */,
-     validateIsPackage,
-     generateExportHeaderForPackage(true /* forJava */)
-    },
-
-    {"vts",
-     "(internal) Generates vts proto files for use in vtsd.",
-     OutputHandler::NEEDS_DIR /* mOutputMode */,
-     validateForSource,
-     generationFunctionForFileOrPackage("vts")
-    },
-
-    {"makefile",
-     "(internal) Generates makefiles for -Ljava and -Ljava-constants.",
-     OutputHandler::NEEDS_SRC /* mOutputMode */,
-     validateIsPackage,
-     generateMakefileForPackage,
-    },
-
-    {"androidbp",
-     "(internal) Generates Soong bp files for -Lc++-headers and -Lc++-sources.",
-     OutputHandler::NEEDS_SRC /* mOutputMode */,
-     validateIsPackage,
-     generateAndroidBpForPackage,
-    },
-
-    {"androidbp-impl",
-     "Generates boilerplate bp files for implementation created with -Lc++-impl.",
-     OutputHandler::NEEDS_DIR /* mOutputMode */,
-     validateIsPackage,
-     generateAndroidBpImplForPackage,
-    },
-
-    {"hash",
-     "Prints hashes of interface in `current.txt` format to standard out.",
-     OutputHandler::NOT_NEEDED /* mOutputMode */,
-     validateForSource,
-     generateHashOutput,
+    {
+        FileGenerator::generateForInterfaces,
+        [](const FQName& fqName) { return fqName.getInterfacePassthroughName() + ".h"; },
+        astGenerationFunction(&AST::generatePassthroughHeader),
     },
 };
 
+static const std::vector<FileGenerator> kCppSourceFormats = {
+    {
+        FileGenerator::alwaysGenerate,
+        [](const FQName& fqName) {
+            return fqName.isInterfaceName() ? fqName.getInterfaceBaseName() + "All.cpp" : "types.cpp";
+        },
+        astGenerationFunction(&AST::generateCppSource),
+    },
+};
+
+static const std::vector<FileGenerator> kCppImplHeaderFormats = {
+    {
+        FileGenerator::generateForInterfaces,
+        [](const FQName& fqName) { return fqName.getInterfaceBaseName() + ".h"; },
+        astGenerationFunction(&AST::generateCppImplHeader),
+    },
+};
+
+static const std::vector<FileGenerator> kCppImplSourceFormats = {
+    {
+        FileGenerator::generateForInterfaces,
+        [](const FQName& fqName) { return fqName.getInterfaceBaseName() + ".cpp"; },
+        astGenerationFunction(&AST::generateCppImplSource),
+    },
+};
+
+static const std::vector<FileGenerator> kCppAdapterHeaderFormats = {
+    {
+        FileGenerator::alwaysGenerate,
+        [](const FQName& fqName) {
+            return fqName.isInterfaceName() ? fqName.getInterfaceAdapterName() + ".h" : "Atypes.h";
+        },
+        astGenerationFunction(&AST::generateCppAdapterHeader),
+    },
+};
+
+static const std::vector<FileGenerator> kCppAdapterSourceFormats = {
+    {
+        FileGenerator::alwaysGenerate,
+        [](const FQName& fqName) {
+            return fqName.isInterfaceName() ? fqName.getInterfaceAdapterName() + ".cpp" : "Atypes.cpp";
+        },
+        astGenerationFunction(&AST::generateCppAdapterSource),
+    },
+};
+
+static const std::vector<OutputHandler> kFormats = {
+    {
+        "check",
+        "Parses the interface to see if valid but doesn't write any files.",
+        OutputMode::NOT_NEEDED,
+        Coordinator::Location::STANDARD_OUT,
+        GenerationGranularity::PER_FILE,
+        validateForSource,
+        {
+            {
+                FileGenerator::alwaysGenerate,
+                nullptr /* filename for fqname */,
+                astGenerationFunction(),
+            },
+        },
+    },
+    {
+        "c++",
+        "(internal) (deprecated) Generates C++ interface files for talking to HIDL interfaces.",
+        OutputMode::NEEDS_DIR,
+        Coordinator::Location::GEN_OUTPUT,
+        GenerationGranularity::PER_FILE,
+        validateForSource,
+        kCppHeaderFormats + kCppSourceFormats,
+    },
+    {
+        "c++-headers",
+        "(internal) Generates C++ headers for interface files for talking to HIDL interfaces.",
+        OutputMode::NEEDS_DIR,
+        Coordinator::Location::GEN_OUTPUT,
+        GenerationGranularity::PER_FILE,
+        validateForSource,
+        kCppHeaderFormats,
+    },
+    {
+        "c++-sources",
+        "(internal) Generates C++ sources for interface files for talking to HIDL interfaces.",
+        OutputMode::NEEDS_DIR,
+        Coordinator::Location::GEN_OUTPUT,
+        GenerationGranularity::PER_FILE,
+        validateForSource,
+        kCppSourceFormats,
+    },
+    {
+        "export-header",
+        "Generates a header file from @export enumerations to help maintain legacy code.",
+        OutputMode::NEEDS_FILE,
+        Coordinator::Location::DIRECT,
+        GenerationGranularity::PER_PACKAGE,
+        validateIsPackage,
+        {singleFileGenerator("", generateExportHeaderForPackage(false /* forJava */))}
+    },
+    {
+        "c++-impl",
+        "Generates boilerplate implementation of a hidl interface in C++ (for convenience).",
+        OutputMode::NEEDS_DIR,
+        Coordinator::Location::DIRECT,
+        GenerationGranularity::PER_FILE,
+        validateForSource,
+        kCppImplHeaderFormats + kCppImplSourceFormats,
+    },
+    {
+        "c++-impl-headers",
+        "c++-impl but headers only",
+        OutputMode::NEEDS_DIR,
+        Coordinator::Location::DIRECT,
+        GenerationGranularity::PER_FILE,
+        validateForSource,
+        kCppImplHeaderFormats,
+    },
+    {
+        "c++-impl-sources",
+        "c++-impl but sources only",
+        OutputMode::NEEDS_DIR,
+        Coordinator::Location::DIRECT,
+        GenerationGranularity::PER_FILE,
+        validateForSource,
+        kCppImplSourceFormats,
+    },
+    {
+        "c++-adapter",
+        "Takes a x.(y+n) interface and mocks an x.y interface.",
+        OutputMode::NEEDS_DIR,
+        Coordinator::Location::GEN_OUTPUT,
+        GenerationGranularity::PER_FILE,
+        validateForSource,
+        kCppAdapterHeaderFormats + kCppAdapterSourceFormats,
+    },
+    {
+        "c++-adapter-headers",
+        "c++-adapter but helper headers only",
+        OutputMode::NEEDS_DIR,
+        Coordinator::Location::GEN_OUTPUT,
+        GenerationGranularity::PER_FILE,
+        validateForSource,
+        kCppAdapterHeaderFormats,
+    },
+    {
+        "c++-adapter-sources",
+        "c++-adapter but helper sources only",
+        OutputMode::NEEDS_DIR,
+        Coordinator::Location::GEN_OUTPUT,
+        GenerationGranularity::PER_FILE,
+        validateForSource,
+        kCppAdapterSourceFormats,
+    },
+    {
+        "c++-adapter-main",
+        "c++-adapter but the adapter binary source only",
+        OutputMode::NEEDS_DIR,
+        Coordinator::Location::DIRECT,
+        GenerationGranularity::PER_PACKAGE,
+        validateIsPackage,
+        {singleFileGenerator("main.cpp", generateAdapterMainSource)},
+    },
+    {
+        "java",
+        "(internal) Generates Java library for talking to HIDL interfaces in Java.",
+        OutputMode::NEEDS_DIR,
+        Coordinator::Location::GEN_SANITIZED,
+        GenerationGranularity::PER_TYPE,
+        validateForSource,
+        {
+            {
+                FileGenerator::alwaysGenerate,
+                [](const FQName& fqName) {
+                    return StringHelper::LTrim(fqName.name(), "types.") + ".java";
+                },
+                generateJavaForPackage,
+            },
+        }
+    },
+    {
+        "java-constants",
+        "(internal) Like export-header but for Java (always created by -Lmakefile if @export exists).",
+        OutputMode::NEEDS_DIR,
+        Coordinator::Location::GEN_SANITIZED,
+        GenerationGranularity::PER_PACKAGE,
+        validateIsPackage,
+        {singleFileGenerator("Constants.java", generateExportHeaderForPackage(true /* forJava */))}
+    },
+    {
+        "vts",
+        "(internal) Generates vts proto files for use in vtsd.",
+        OutputMode::NEEDS_DIR,
+        Coordinator::Location::GEN_OUTPUT,
+        GenerationGranularity::PER_FILE,
+        validateForSource,
+        {
+            {
+                FileGenerator::alwaysGenerate,
+                [](const FQName& fqName) {
+                    return fqName.isInterfaceName() ? fqName.getInterfaceBaseName() + ".vts" : "types.vts";
+                },
+                astGenerationFunction(&AST::generateVts),
+            },
+        }
+    },
+    {
+        "makefile",
+        "(removed) Used to generate makefiles for -Ljava and -Ljava-constants.",
+        OutputMode::NEEDS_SRC,
+        Coordinator::Location::PACKAGE_ROOT,
+        GenerationGranularity::PER_PACKAGE,
+        [](const FQName &, const Coordinator*, const std::string &) {
+           fprintf(stderr, "ERROR: makefile output is not supported. Use -Landroidbp for all build file generation.\n");
+           return false;
+        },
+        {},
+    },
+    {
+        "androidbp",
+        "(internal) Generates Soong bp files for -Lc++-headers, -Lc++-sources, -Ljava, -Ljava-constants, and -Lc++-adapter.",
+        OutputMode::NEEDS_SRC,
+        Coordinator::Location::PACKAGE_ROOT,
+        GenerationGranularity::PER_PACKAGE,
+        validateIsPackage,
+        {singleFileGenerator("Android.bp", generateAndroidBpForPackage)},
+    },
+    {
+        "androidbp-impl",
+        "Generates boilerplate bp files for implementation created with -Lc++-impl.",
+        OutputMode::NEEDS_DIR,
+        Coordinator::Location::DIRECT,
+        GenerationGranularity::PER_PACKAGE,
+        validateIsPackage,
+        {singleFileGenerator("Android.bp", generateAndroidBpImplForPackage)},
+    },
+    {
+        "hash",
+        "Prints hashes of interface in `current.txt` format to standard out.",
+        OutputMode::NOT_NEEDED,
+        Coordinator::Location::STANDARD_OUT,
+        GenerationGranularity::PER_FILE,
+        validateForSource,
+        {
+            {
+                FileGenerator::alwaysGenerate,
+                nullptr /* file name for fqName */,
+                generateHashOutput,
+            },
+        }
+    },
+};
+// clang-format on
+
 static void usage(const char *me) {
     fprintf(stderr,
-            "usage: %s [-p <root path>] -o <output path> -L <language> (-r <interface root>)+ [-t] "
-            "fqname+\n",
+            "usage: %s [-p <root path>] -o <output path> -L <language> [-O <owner>] (-r <interface "
+            "root>)+ [-v] [-d <depfile>] FQNAME...\n\n",
             me);
 
+    fprintf(stderr,
+            "Process FQNAME, PACKAGE(.SUBPACKAGE)*@[0-9]+.[0-9]+(::TYPE)?, to create output.\n\n");
+
     fprintf(stderr, "         -h: Prints this menu.\n");
     fprintf(stderr, "         -L <language>: The following options are available:\n");
-    for (auto &e : formats) {
+    for (auto& e : kFormats) {
         fprintf(stderr, "            %-16s: %s\n", e.name().c_str(), e.description().c_str());
     }
+    fprintf(stderr, "         -O <owner>: The owner of the module for -Landroidbp(-impl)?.\n");
     fprintf(stderr, "         -o <output path>: Location to output files.\n");
     fprintf(stderr, "         -p <root path>: Android build root, defaults to $ANDROID_BUILD_TOP or pwd.\n");
     fprintf(stderr, "         -r <package:path root>: E.g., android.hardware:hardware/interfaces.\n");
-    fprintf(stderr, "         -t: generate build scripts (Android.bp) for tests.\n");
+    fprintf(stderr, "         -v: verbose output.\n");
+    fprintf(stderr, "         -d <depfile>: location of depfile to write to.\n");
 }
 
 // hidl is intentionally leaky. Turn off LeakSanitizer by default.
@@ -1333,36 +1205,57 @@
 }
 
 int main(int argc, char **argv) {
-    std::string outputPath;
-    std::string rootPath;
-    std::vector<std::string> packageRootPaths;
-    std::vector<std::string> packageRoots;
-
     const char *me = argv[0];
-    OutputHandler *outputFormat = nullptr;
-
     if (argc == 1) {
         usage(me);
         exit(1);
     }
 
+    const OutputHandler* outputFormat = nullptr;
+    Coordinator coordinator;
+    std::string outputPath;
+
     int res;
-    while ((res = getopt(argc, argv, "hp:o:r:L:t")) >= 0) {
+    while ((res = getopt(argc, argv, "hp:o:O:r:L:vd:")) >= 0) {
         switch (res) {
-            case 'p':
-            {
-                rootPath = optarg;
+            case 'p': {
+                if (!coordinator.getRootPath().empty()) {
+                    fprintf(stderr, "ERROR: -p <root path> can only be specified once.\n");
+                    exit(1);
+                }
+                coordinator.setRootPath(optarg);
                 break;
             }
 
-            case 'o':
-            {
+            case 'v': {
+                coordinator.setVerbose(true);
+                break;
+            }
+
+            case 'd': {
+                coordinator.setDepFile(optarg);
+                break;
+            }
+
+            case 'o': {
+                if (!outputPath.empty()) {
+                    fprintf(stderr, "ERROR: -o <output path> can only be specified once.\n");
+                    exit(1);
+                }
                 outputPath = optarg;
                 break;
             }
 
-            case 'r':
-            {
+            case 'O': {
+                if (!coordinator.getOwner().empty()) {
+                    fprintf(stderr, "ERROR: -O <owner> can only be specified once.\n");
+                    exit(1);
+                }
+                coordinator.setOwner(optarg);
+                break;
+            }
+
+            case 'r': {
                 std::string val(optarg);
                 auto index = val.find_first_of(':');
                 if (index == std::string::npos) {
@@ -1370,22 +1263,27 @@
                     exit(1);
                 }
 
-                auto package = val.substr(0, index);
+                auto root = val.substr(0, index);
                 auto path = val.substr(index + 1);
-                packageRootPaths.push_back(path);
-                packageRoots.push_back(package);
+
+                std::string error;
+                status_t err = coordinator.addPackagePath(root, path, &error);
+                if (err != OK) {
+                    fprintf(stderr, "%s\n", error.c_str());
+                    exit(1);
+                }
+
                 break;
             }
 
-            case 'L':
-            {
+            case 'L': {
                 if (outputFormat != nullptr) {
                     fprintf(stderr,
                             "ERROR: only one -L option allowed. \"%s\" already specified.\n",
                             outputFormat->name().c_str());
                     exit(1);
                 }
-                for (auto &e : formats) {
+                for (auto& e : kFormats) {
                     if (e.name() == optarg) {
                         outputFormat = &e;
                         break;
@@ -1400,15 +1298,9 @@
                 break;
             }
 
-            case 't': {
-                generateForTest = true;
-                break;
-            }
-
             case '?':
             case 'h':
-            default:
-            {
+            default: {
                 usage(me);
                 exit(1);
                 break;
@@ -1416,17 +1308,19 @@
         }
     }
 
+    if (coordinator.getRootPath().empty()) {
+        const char* ANDROID_BUILD_TOP = getenv("ANDROID_BUILD_TOP");
+        if (ANDROID_BUILD_TOP != nullptr) {
+            coordinator.setRootPath(ANDROID_BUILD_TOP);
+        }
+    }
+
     if (outputFormat == nullptr) {
         fprintf(stderr,
             "ERROR: no -L option provided.\n");
         exit(1);
     }
 
-    if (generateForTest && outputFormat->name() != "androidbp") {
-        fprintf(stderr, "ERROR: -t option is for -Landroidbp only.\n");
-        exit(1);
-    }
-
     argc -= optind;
     argv += optind;
 
@@ -1436,43 +1330,29 @@
         exit(1);
     }
 
-    if (rootPath.empty()) {
-        const char *ANDROID_BUILD_TOP = getenv("ANDROID_BUILD_TOP");
-
-        if (ANDROID_BUILD_TOP != nullptr) {
-            rootPath = ANDROID_BUILD_TOP;
-        }
-
-        // else default to pwd
-    }
-
-    if (!rootPath.empty() && !StringHelper::EndsWith(rootPath, "/")) {
-        rootPath += "/";
-    }
-
     // Valid options are now in argv[0] .. argv[argc - 1].
 
     switch (outputFormat->mOutputMode) {
-        case OutputHandler::NEEDS_DIR:
-        case OutputHandler::NEEDS_FILE:
-        {
+        case OutputMode::NEEDS_DIR:
+        case OutputMode::NEEDS_FILE: {
             if (outputPath.empty()) {
                 usage(me);
                 exit(1);
             }
 
-            if (outputFormat->mOutputMode == OutputHandler::NEEDS_DIR) {
-                const size_t len = outputPath.size();
-                if (outputPath[len - 1] != '/') {
+            if (outputFormat->mOutputMode == OutputMode::NEEDS_DIR) {
+                if (outputPath.back() != '/') {
                     outputPath += "/";
                 }
             }
             break;
         }
-        case OutputHandler::NEEDS_SRC:
-        {
+        case OutputMode::NEEDS_SRC: {
             if (outputPath.empty()) {
-                outputPath = rootPath;
+                outputPath = coordinator.getRootPath();
+            }
+            if (outputPath.back() != '/') {
+                outputPath += "/";
             }
 
             break;
@@ -1483,33 +1363,38 @@
             break;
     }
 
-    Coordinator coordinator(packageRootPaths, packageRoots, rootPath);
+    coordinator.setOutputPath(outputPath);
+
     coordinator.addDefaultPackagePath("android.hardware", "hardware/interfaces");
     coordinator.addDefaultPackagePath("android.hidl", "system/libhidl/transport");
     coordinator.addDefaultPackagePath("android.frameworks", "frameworks/hardware/interfaces");
     coordinator.addDefaultPackagePath("android.system", "system/hardware/interfaces");
 
     for (int i = 0; i < argc; ++i) {
-        FQName fqName(argv[i]);
-
-        if (!fqName.isValid()) {
-            fprintf(stderr,
-                    "ERROR: Invalid fully-qualified name.\n");
+        FQName fqName;
+        if (!FQName::parse(argv[i], &fqName)) {
+            fprintf(stderr, "ERROR: Invalid fully-qualified name as argument: %s.\n", argv[i]);
             exit(1);
         }
 
-        if (!outputFormat->validate(fqName, outputFormat->name())) {
+        // Dump extra verbose output
+        if (coordinator.isVerbose()) {
+            status_t err =
+                dumpDefinedButUnreferencedTypeNames(fqName.getPackageAndVersion(), &coordinator);
+            if (err != OK) return err;
+        }
+
+        if (!outputFormat->validate(fqName, &coordinator, outputFormat->name())) {
             fprintf(stderr,
                     "ERROR: output handler failed.\n");
             exit(1);
         }
 
-        status_t err =
-            outputFormat->generate(fqName, me, &coordinator, outputPath);
+        status_t err = outputFormat->generate(fqName, &coordinator);
+        if (err != OK) exit(1);
 
-        if (err != OK) {
-            exit(1);
-        }
+        err = outputFormat->writeDepFile(fqName, &coordinator);
+        if (err != OK) exit(1);
     }
 
     return 0;
diff --git a/scripts/run-tests.sh b/scripts/run-tests.sh
new file mode 100755
index 0000000..bb6f7d7
--- /dev/null
+++ b/scripts/run-tests.sh
@@ -0,0 +1,114 @@
+#!/bin/bash
+
+# See hal_hidl_gtest.py
+
+THREADS=
+CHECKER=vts_testability_checker
+CHECKER_DEVICE_PATH="/data/local/tmp/${CHECKER}"
+PRINT_COMMANDS=
+
+function run() {
+    if [ "${PRINT_COMMANDS}" = true ] ; then
+        >&2 echo "*** $@"
+    fi
+    $@
+}
+
+function make_modules() {
+    if [ "${THREADS}" != "0" ] ; then
+        run make -j${THREADS} -C ${ANDROID_BUILD_TOP} -f build/core/main.mk $@
+    fi
+}
+
+function push_checker() {
+    run adb push ${OUT}/system/bin/${CHECKER} ${CHECKER_DEVICE_PATH}
+}
+
+function push_test() {
+    local module=$1
+    for test_dir in nativetest nativetest64 ; do
+        local test_file=/data/${test_dir}/${module}/${module}
+        run adb push ${OUT}${test_file} ${test_file}
+    done
+}
+
+function read_checker_output() {
+    python -c 'import json,sys;obj=json.load(sys.stdin);sys.stdout.write("%s\n"%obj["Testable"]);map(lambda i:sys.stdout.write("%s\n"%i),obj["instances"])'
+}
+
+function run_test() {
+    local module=$1
+    local status=0
+
+    for test_dir in nativetest nativetest64 ; do
+        local test_file=/data/${test_dir}/${module}/${module}
+        local interfaces=$(run adb shell ${test_file} --list_registered_services \
+            | sed -n 's/^hal_service: \(.*\)$/\1/p')
+        if [ -z "$interfaces" ]; then
+            run adb shell ${test_file} || status=$?
+        else
+            for interface in ${interfaces} ; do
+                local output=$(run adb shell ${CHECKER_DEVICE_PATH} -c ${interface} | read_checker_output)
+                local testable=$(echo "${output}" | head -n1)
+                local instances=$(echo "${output}" | tail -n+2)
+
+                if [ "${testable}" == "True" ] ; then
+                    for instance in ${instances} ; do
+                        run adb shell ${test_file} --hal_service_instance="${interface}/${instance}" || status=$?
+                    done
+                fi
+            done
+        fi
+    done
+    return ${status}
+}
+
+function usage() {
+    echo "usage: $0 -m <module_name> [-m <module_name>[...]] [-j <jobs>] [-p]"
+    echo "          -m <module_name>: name of test (e.g. VtsHalHealthV2_0TargetTest)"
+    echo "          -p: print commands"
+    echo "          -j <jobs>: # jobs in make. "
+    echo "                     -j0 skips making any modules."
+    echo "                     If not present, use infinite number of jobs."
+
+    exit 1
+}
+
+function main() {
+    local modules=
+
+    while getopts "m:j:p" option ; do
+        case "${option}" in
+            m)
+                [ ! -z ${OPTARG} ] || usage
+                modules="${modules} ${OPTARG}"
+                ;;
+            j)
+                THREADS=${OPTARG}
+                ;;
+            p)
+                PRINT_COMMANDS=true
+                ;;
+            *)
+                usage
+                ;;
+        esac
+    done
+
+    set -e
+    make_modules ${CHECKER} ${modules}
+    run adb root
+    push_checker
+    for module in ${modules} ; do
+        push_test ${module}
+    done
+
+    set +e
+    local status=0
+    for module in ${modules} ; do
+        run_test ${module} || status=$?
+    done
+    return ${status}
+}
+
+main $@
diff --git a/test/Android.bp b/test/Android.bp
deleted file mode 100644
index 08aed77..0000000
--- a/test/Android.bp
+++ /dev/null
@@ -1,80 +0,0 @@
-subdirs = [
-    "error_test",
-    "hash_test",
-    "impl_test",
-    "java_test",
-    "vendor/1.0",
-    "vendor/1.1",
-    "version_test",
-]
-
-cc_test {
-    name: "hidl_test_client",
-    cflags: hidl_flags,
-    srcs: ["hidl_test_client.cpp", "FooCallback.cpp"],
-
-    shared_libs: [
-        "libbase",
-        "liblog",
-        "libcutils",
-        "libhidlbase",
-        "libhidltransport",
-        "libhidlmemory",
-        "libfootest",
-        "libhwbinder",
-        "libpointertest",
-        "libutils",
-        "android.hardware.tests.foo@1.0",
-        "android.hardware.tests.bar@1.0",
-        "android.hardware.tests.baz@1.0",
-        "android.hardware.tests.hash@1.0",
-        "android.hardware.tests.inheritance@1.0",
-        "android.hardware.tests.pointer@1.0",
-        "android.hardware.tests.memory@1.0",
-        "android.hardware.tests.multithread@1.0",
-        "android.hidl.allocator@1.0",
-        "android.hidl.memory@1.0",
-        "android.hidl.token@1.0",
-    ],
-
-    required: [
-        // Warning, these should never be specified explicitly for anything else
-        // as for a given device, what hal implementation is used is determined
-        // by what is specified/available in a device.mk. However, this test
-        // actually depends on these test implementations (which should never be
-        // included on a device.mk).
-        "android.hardware.tests.foo@1.0-impl",
-        "android.hardware.tests.bar@1.0-impl",
-        "android.hardware.tests.baz@1.0-impl",
-        "android.hardware.tests.hash@1.0-impl",
-        "android.hardware.tests.inheritance@1.0-impl",
-        "android.hardware.tests.pointer@1.0-impl",
-        "android.hardware.tests.memory@1.0-impl",
-        "android.hardware.tests.multithread@1.0-impl",
-    ],
-}
-
-cc_test {
-    name: "hidl_test_servers",
-    srcs: ["hidl_test_servers.cpp"],
-    gtest: false,
-
-    shared_libs: [
-        "libbase",
-        "libhidlbase",
-        "libhidltransport",
-        "libhwbinder",
-        "liblog",
-        "libutils",
-        "android.hardware.tests.foo@1.0",
-        "android.hardware.tests.bar@1.0",
-        "android.hardware.tests.baz@1.0",
-        "android.hardware.tests.hash@1.0",
-        "android.hardware.tests.inheritance@1.0",
-        "android.hardware.tests.pointer@1.0",
-        "android.hardware.tests.memory@1.0",
-        "android.hardware.tests.multithread@1.0",
-        "android.hidl.memory@1.0",
-        "android.hidl.token@1.0",
-    ],
-}
diff --git a/test/AndroidTest.xml b/test/AndroidTest.xml
deleted file mode 100644
index e78aac5..0000000
--- a/test/AndroidTest.xml
+++ /dev/null
@@ -1,73 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<!-- Copyright (C) 2016 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.
--->
-<configuration description="Config for VTS HIDL unit tests">
-    <option name="config-descriptor:metadata" key="plan" value="vts-library" />
-    <target_preparer class="com.android.compatibility.common.tradefed.targetprep.VtsFilePusher">
-        <option name="push-group" value="HostDrivenTest.push" />
-        <option name="cleanup" value="true" />
-        <option name="push" value="DATA/nativetest/hidl_test_servers/hidl_test_servers->/data/nativetest/hidl_test_servers/hidl_test_servers" />
-        <option name="push" value="DATA/nativetest64/hidl_test_servers/hidl_test_servers->/data/nativetest64/hidl_test_servers/hidl_test_servers" />
-        <option name="push" value="DATA/nativetest/hidl_test_client/hidl_test_client->/data/nativetest/hidl_test_client/hidl_test_client" />
-        <option name="push" value="DATA/nativetest64/hidl_test_client/hidl_test_client->/data/nativetest64/hidl_test_client/hidl_test_client" />
-        <option name="push" value="DATA/nativetest64/hidl_test_helper->/data/nativetest64/hidl_test_helper" />
-        <option name="push" value="DATA/nativetest64/hidl_test->/data/nativetest64/hidl_test" />
-        <option name="push" value="DATA/lib/libfootest.so->/data/local/tmp/system/lib/libfootest.so" />
-        <option name="push" value="DATA/lib64/libfootest.so->/data/local/tmp/system/lib64/libfootest.so" />
-        <option name="push" value="DATA/lib/libpointertest.so->/data/local/tmp/system/lib/libpointertest.so" />
-        <option name="push" value="DATA/lib64/libpointertest.so->/data/local/tmp/system/lib64/libpointertest.so" />
-        <option name="push" value="DATA/lib/android.hardware.tests.foo@1.0.so->/data/local/tmp/system/lib/android.hardware.tests.foo@1.0.so" />
-        <option name="push" value="DATA/lib64/android.hardware.tests.foo@1.0.so->/data/local/tmp/system/lib64/android.hardware.tests.foo@1.0.so" />
-        <option name="push" value="DATA/lib/android.hardware.tests.bar@1.0.so->/data/local/tmp/system/lib/android.hardware.tests.bar@1.0.so" />
-        <option name="push" value="DATA/lib64/android.hardware.tests.bar@1.0.so->/data/local/tmp/system/lib64/android.hardware.tests.bar@1.0.so" />
-        <option name="push" value="DATA/lib/android.hardware.tests.baz@1.0.so->/data/local/tmp/system/lib/android.hardware.tests.baz@1.0.so" />
-        <option name="push" value="DATA/lib64/android.hardware.tests.baz@1.0.so->/data/local/tmp/system/lib64/android.hardware.tests.baz@1.0.so" />
-        <option name="push" value="DATA/lib/android.hardware.tests.hash@1.0.so->/data/local/tmp/system/lib/android.hardware.tests.hash@1.0.so" />
-        <option name="push" value="DATA/lib64/android.hardware.tests.hash@1.0.so->/data/local/tmp/system/lib64/android.hardware.tests.hash@1.0.so" />
-        <option name="push" value="DATA/lib/android.hardware.tests.inheritance@1.0.so->/data/local/tmp/system/lib/android.hardware.tests.inheritance@1.0.so" />
-        <option name="push" value="DATA/lib64/android.hardware.tests.inheritance@1.0.so->/data/local/tmp/system/lib64/android.hardware.tests.inheritance@1.0.so" />
-        <option name="push" value="DATA/lib/android.hardware.tests.pointer@1.0.so->/data/local/tmp/system/lib/android.hardware.tests.pointer@1.0.so" />
-        <option name="push" value="DATA/lib64/android.hardware.tests.pointer@1.0.so->/data/local/tmp/system/lib64/android.hardware.tests.pointer@1.0.so" />
-        <option name="push" value="DATA/lib/android.hardware.tests.memory@1.0.so->/data/local/tmp/system/lib/android.hardware.tests.memory@1.0.so" />
-        <option name="push" value="DATA/lib64/android.hardware.tests.memory@1.0.so->/data/local/tmp/system/lib64/android.hardware.tests.memory@1.0.so" />
-        <option name="push" value="DATA/lib/android.hardware.tests.multithread@1.0.so->/data/local/tmp/system/lib/android.hardware.tests.multithread@1.0.so" />
-        <option name="push" value="DATA/lib64/android.hardware.tests.multithread@1.0.so->/data/local/tmp/system/lib64/android.hardware.tests.multithread@1.0.so" />
-        <option name="push" value="DATA/lib/hw/android.hardware.tests.foo@1.0-impl.so->/data/local/tmp/system/lib/hw/android.hardware.tests.foo@1.0-impl.so" />
-        <option name="push" value="DATA/lib64/hw/android.hardware.tests.foo@1.0-impl.so->/data/local/tmp/system/lib64/hw/android.hardware.tests.foo@1.0-impl.so" />
-        <option name="push" value="DATA/lib/hw/android.hardware.tests.bar@1.0-impl.so->/data/local/tmp/system/lib/hw/android.hardware.tests.bar@1.0-impl.so" />
-        <option name="push" value="DATA/lib64/hw/android.hardware.tests.bar@1.0-impl.so->/data/local/tmp/system/lib64/hw/android.hardware.tests.bar@1.0-impl.so" />
-        <option name="push" value="DATA/lib/hw/android.hardware.tests.baz@1.0-impl.so->/data/local/tmp/system/lib/hw/android.hardware.tests.baz@1.0-impl.so" />
-        <option name="push" value="DATA/lib64/hw/android.hardware.tests.baz@1.0-impl.so->/data/local/tmp/system/lib64/hw/android.hardware.tests.baz@1.0-impl.so" />
-        <option name="push" value="DATA/lib/hw/android.hardware.tests.hash@1.0-impl.so->/data/local/tmp/system/lib/hw/android.hardware.tests.hash@1.0-impl.so" />
-        <option name="push" value="DATA/lib64/hw/android.hardware.tests.hash@1.0-impl.so->/data/local/tmp/system/lib64/hw/android.hardware.tests.hash@1.0-impl.so" />
-        <option name="push" value="DATA/lib/hw/android.hardware.tests.inheritance@1.0-impl.so->/data/local/tmp/system/lib/hw/android.hardware.tests.inheritance@1.0-impl.so" />
-        <option name="push" value="DATA/lib64/hw/android.hardware.tests.inheritance@1.0-impl.so->/data/local/tmp/system/lib64/hw/android.hardware.tests.inheritance@1.0-impl.so" />
-        <option name="push" value="DATA/lib/hw/android.hardware.tests.pointer@1.0-impl.so->/data/local/tmp/system/lib/hw/android.hardware.tests.pointer@1.0-impl.so" />
-        <option name="push" value="DATA/lib64/hw/android.hardware.tests.pointer@1.0-impl.so->/data/local/tmp/system/lib64/hw/android.hardware.tests.pointer@1.0-impl.so" />
-        <option name="push" value="DATA/lib/hw/android.hardware.tests.memory@1.0-impl.so->/data/local/tmp/system/lib/hw/android.hardware.tests.memory@1.0-impl.so" />
-        <option name="push" value="DATA/lib64/hw/android.hardware.tests.memory@1.0-impl.so->/data/local/tmp/system/lib64/hw/android.hardware.tests.memory@1.0-impl.so" />
-        <option name="push" value="DATA/lib/hw/android.hardware.tests.multithread@1.0-impl.so->/data/local/tmp/system/lib/hw/android.hardware.tests.multithread@1.0-impl.so" />
-        <option name="push" value="DATA/lib64/hw/android.hardware.tests.multithread@1.0-impl.so->/data/local/tmp/system/lib64/hw/android.hardware.tests.multithread@1.0-impl.so" />
-    </target_preparer>
-    <target_preparer class="com.android.tradefed.targetprep.VtsPythonVirtualenvPreparer" />
-    <test class="com.android.tradefed.testtype.VtsMultiDeviceTest">
-      <option name="test-module-name" value="VtsHidlUnitTests" />
-      <option name="binary-test-type" value="binary_test" />
-      <option name="binary-test-source" value="DATA/nativetest64/hidl_test->/data/nativetest64/hidl_test" />
-      <option name="binary-test-envp" value="VTS_ROOT_PATH=/data/local/tmp" />
-      <option name="binary-test-args" value="-x /data/local/tmp/system/lib" />
-      <option name="binary-test-args" value="-y /data/local/tmp/system/lib64" />
-    </test>
-</configuration>
diff --git a/test/error_test/Android.bp b/test/error_test/Android.bp
index bd5c076..42345b2 100644
--- a/test/error_test/Android.bp
+++ b/test/error_test/Android.bp
@@ -1,51 +1,20 @@
 genrule {
     name: "hidl_error_test_gen",
-    tools: [
-        "hidl-gen",
-    ],
-    cmd: "!($(location hidl-gen) -L check " +
-         "    -r test.error:system/tools/hidl/test/error_test/interface_semicolon" +
-         "    test.error.error@1.0  >/dev/null 2>&1)" +
-         "&&" +
-         "!($(location hidl-gen) -L check " +
-         "    -r test.error:system/tools/hidl/test/error_test/method_ends_in_semicolon" +
-         "    test.error.error@1.0  >/dev/null 2>&1)" +
-         "&&" +
-         "!($(location hidl-gen) -L check " +
-         "    -r test.error:system/tools/hidl/test/error_test/no_data_outside_interface" +
-         "    test.error.error@1.0  >/dev/null 2>&1)" +
-         "&&" +
-         "!($(location hidl-gen) -L check " +
-         "    -r test.error:system/tools/hidl/test/error_test/no_interface_in_types" +
-         "    test.error.error@1.0  >/dev/null 2>&1)" +
-         "&&" +
-         "!($(location hidl-gen) -L check " +
-         "    -r test.error:system/tools/hidl/test/error_test/no_two_interfaces" +
-         "    test.error.error@1.0  >/dev/null 2>&1)" +
-         "&&" +
-         "!($(location hidl-gen) -L check " +
-         "    -r test.error:system/tools/hidl/test/error_test/same_name_interface" +
-         "    test.error.error@1.0  >/dev/null 2>&1)" +
-         "&&" +
-         "!($(location hidl-gen) -L check " +
-         "    -r test.error:system/tools/hidl/test/error_test/same_package_name" +
-         "    test.error.error@1.0  >/dev/null 2>&1)" +
-         "&&" +
+    tools: ["hidl-gen"],
+    tool_files: ["hidl_error_test.sh"],
+    cmd: "$(location hidl_error_test.sh) $(location hidl-gen) &&" +
          "echo 'int main(){return 0;}' > $(genDir)/TODO_b_37575883.cpp",
     out: ["TODO_b_37575883.cpp"],
     srcs: [
-        "interface_semicolon/error/1.0/IFoo.hal",
-        "method_ends_in_semicolon/error/1.0/IFoo.hal",
-        "no_data_outside_interface/error/1.0/IFoo.hal",
-        "no_interface_in_types/error/1.0/IFoo.hal",
-        "no_interface_in_types/error/1.0/types.hal",
-        "no_two_interfaces/error/1.0/IFoo.hal",
-        "same_name_interface/error/1.0/IFoo.hal",
-        "same_package_name/error/1.0/IFoo.hal",
+        "hidl_error_test.sh",
+
+        "**/*.hal",
+        "**/required_error",
     ],
 }
 
 cc_test_host {
     name: "hidl_error_test",
+    cflags: ["-Wall", "-Werror"],
     generated_sources: ["hidl_error_test_gen"],
 }
diff --git a/test/error_test/no_interface_in_types/error/1.0/IFoo.hal b/test/error_test/bad_character/1.0/IFoo.hal
similarity index 93%
copy from test/error_test/no_interface_in_types/error/1.0/IFoo.hal
copy to test/error_test/bad_character/1.0/IFoo.hal
index d79e6ab..9164ee5 100644
--- a/test/error_test/no_interface_in_types/error/1.0/IFoo.hal
+++ b/test/error_test/bad_character/1.0/IFoo.hal
@@ -13,7 +13,9 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-package test.error.error@1.0;
+package test.bad_character@1.0;
+
+😄
 
 interface IFoo {
-};
\ No newline at end of file
+};
diff --git a/test/error_test/bad_character/1.0/required_error b/test/error_test/bad_character/1.0/required_error
new file mode 100644
index 0000000..ab3b3e7
--- /dev/null
+++ b/test/error_test/bad_character/1.0/required_error
@@ -0,0 +1 @@
+syntax error, unexpected unknown character
\ No newline at end of file
diff --git a/test/error_test/cpp_forward_decl_restriction/1.0/required_error b/test/error_test/cpp_forward_decl_restriction/1.0/required_error
new file mode 100644
index 0000000..0426995
--- /dev/null
+++ b/test/error_test/cpp_forward_decl_restriction/1.0/required_error
@@ -0,0 +1 @@
+C++ forward declaration doesn't support inner types
\ No newline at end of file
diff --git a/test/error_test/no_interface_in_types/error/1.0/IFoo.hal b/test/error_test/cpp_forward_decl_restriction/1.0/types.hal
similarity index 74%
copy from test/error_test/no_interface_in_types/error/1.0/IFoo.hal
copy to test/error_test/cpp_forward_decl_restriction/1.0/types.hal
index d79e6ab..17d2aa9 100644
--- a/test/error_test/no_interface_in_types/error/1.0/IFoo.hal
+++ b/test/error_test/cpp_forward_decl_restriction/1.0/types.hal
@@ -13,7 +13,14 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-package test.error.error@1.0;
+package test.cpp_forward_decl_restriction@1.0;
 
-interface IFoo {
-};
\ No newline at end of file
+struct A {
+    // Requires A.B.C to be forward declared in A,
+    // which is not supported in C++.
+    A.B.C foo;
+
+    struct B {
+        struct C {};
+    };
+};
diff --git a/test/error_test/no_interface_in_types/error/1.0/IFoo.hal b/test/error_test/doc_comment_ends_block/1.0/IFoo.hal
similarity index 88%
copy from test/error_test/no_interface_in_types/error/1.0/IFoo.hal
copy to test/error_test/doc_comment_ends_block/1.0/IFoo.hal
index d79e6ab..26c768e 100644
--- a/test/error_test/no_interface_in_types/error/1.0/IFoo.hal
+++ b/test/error_test/doc_comment_ends_block/1.0/IFoo.hal
@@ -13,7 +13,11 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-package test.error.error@1.0;
+package test.empty_generates@1.0;
 
 interface IFoo {
-};
\ No newline at end of file
+    doFoo();
+    /**
+     * Does foo!
+     */
+};
diff --git a/test/error_test/doc_comment_ends_block/1.0/required_error b/test/error_test/doc_comment_ends_block/1.0/required_error
new file mode 100644
index 0000000..94c947a
--- /dev/null
+++ b/test/error_test/doc_comment_ends_block/1.0/required_error
@@ -0,0 +1 @@
+Doc comments must preceed what they describe at
\ No newline at end of file
diff --git a/test/error_test/no_interface_in_types/error/1.0/IFoo.hal b/test/error_test/empty_generates/1.0/IFoo.hal
similarity index 91%
copy from test/error_test/no_interface_in_types/error/1.0/IFoo.hal
copy to test/error_test/empty_generates/1.0/IFoo.hal
index d79e6ab..1ad23e0 100644
--- a/test/error_test/no_interface_in_types/error/1.0/IFoo.hal
+++ b/test/error_test/empty_generates/1.0/IFoo.hal
@@ -13,7 +13,8 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-package test.error.error@1.0;
+package test.empty_generates@1.0;
 
 interface IFoo {
-};
\ No newline at end of file
+    foo() generates ();
+};
diff --git a/test/error_test/empty_generates/1.0/required_error b/test/error_test/empty_generates/1.0/required_error
new file mode 100644
index 0000000..ce24040
--- /dev/null
+++ b/test/error_test/empty_generates/1.0/required_error
@@ -0,0 +1 @@
+generates clause used without result at
\ No newline at end of file
diff --git a/test/error_test/no_interface_in_types/error/1.0/IFoo.hal b/test/error_test/enum_storage/1.0/IFoo.hal
similarity index 88%
copy from test/error_test/no_interface_in_types/error/1.0/IFoo.hal
copy to test/error_test/enum_storage/1.0/IFoo.hal
index d79e6ab..68f17c9 100644
--- a/test/error_test/no_interface_in_types/error/1.0/IFoo.hal
+++ b/test/error_test/enum_storage/1.0/IFoo.hal
@@ -13,7 +13,12 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-package test.error.error@1.0;
+package test.bad_character@1.0;
 
 interface IFoo {
-};
\ No newline at end of file
+
+    enum A /* missing storage */ {
+    };
+
+};
+
diff --git a/test/error_test/enum_storage/1.0/required_error b/test/error_test/enum_storage/1.0/required_error
new file mode 100644
index 0000000..aeb0e84
--- /dev/null
+++ b/test/error_test/enum_storage/1.0/required_error
@@ -0,0 +1 @@
+Must explicitly specify enum storage type
\ No newline at end of file
diff --git a/test/error_test/no_interface_in_types/error/1.0/IFoo.hal b/test/error_test/enum_unique_field_names/1.0/IFoo.hal
similarity index 82%
copy from test/error_test/no_interface_in_types/error/1.0/IFoo.hal
copy to test/error_test/enum_unique_field_names/1.0/IFoo.hal
index d79e6ab..69818e8 100644
--- a/test/error_test/no_interface_in_types/error/1.0/IFoo.hal
+++ b/test/error_test/enum_unique_field_names/1.0/IFoo.hal
@@ -13,7 +13,12 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-package test.error.error@1.0;
+package test.enum_unique_field_names@1.0;
 
 interface IFoo {
-};
\ No newline at end of file
+    enum E : int32_t {
+        A,
+        B,
+        A,  // duplicates first value name
+    };
+};
diff --git a/test/error_test/enum_unique_field_names/1.0/required_error b/test/error_test/enum_unique_field_names/1.0/required_error
new file mode 100644
index 0000000..26d6385
--- /dev/null
+++ b/test/error_test/enum_unique_field_names/1.0/required_error
@@ -0,0 +1 @@
+Redefinition of value 'A'
\ No newline at end of file
diff --git a/test/error_test/no_interface_in_types/error/1.0/IFoo.hal b/test/error_test/enum_unique_field_names_extends/1.0/IFoo.hal
similarity index 76%
copy from test/error_test/no_interface_in_types/error/1.0/IFoo.hal
copy to test/error_test/enum_unique_field_names_extends/1.0/IFoo.hal
index d79e6ab..a2e4642 100644
--- a/test/error_test/no_interface_in_types/error/1.0/IFoo.hal
+++ b/test/error_test/enum_unique_field_names_extends/1.0/IFoo.hal
@@ -13,7 +13,18 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-package test.error.error@1.0;
+package test.enum_unique_field_names_extends@1.0;
 
 interface IFoo {
-};
\ No newline at end of file
+    enum E1 : int32_t {
+        A,
+        B,
+        C,
+    };
+
+    enum E2 : E1 {
+        D,
+        B,  // duplicates E1.B name
+        F,
+    };
+};
diff --git a/test/error_test/enum_unique_field_names_extends/1.0/required_error b/test/error_test/enum_unique_field_names_extends/1.0/required_error
new file mode 100644
index 0000000..dbb4cdb
--- /dev/null
+++ b/test/error_test/enum_unique_field_names_extends/1.0/required_error
@@ -0,0 +1 @@
+Redefinition of value 'B' defined in enum
\ No newline at end of file
diff --git a/test/error_test/hidl_error_test.sh b/test/error_test/hidl_error_test.sh
new file mode 100755
index 0000000..2f5d522
--- /dev/null
+++ b/test/error_test/hidl_error_test.sh
@@ -0,0 +1,34 @@
+#!/bin/bash
+
+if [ $# -ne 1 ]; then
+    echo "usage: hidl_error_test.sh hidl-gen_path"
+    exit 1
+fi
+
+readonly HIDL_GEN_PATH=$1
+readonly HIDL_ERROR_TEST_DIR="$ANDROID_BUILD_TOP/system/tools/hidl/test/error_test"
+
+for dir in $(ls -d $HIDL_ERROR_TEST_DIR/*/); do
+  package=$(basename $dir)
+  output=$($HIDL_GEN_PATH -L check -r test:$HIDL_ERROR_TEST_DIR test.$package@1.0 2>&1)
+  command_fails=$?
+  error=$(cat $HIDL_ERROR_TEST_DIR/$package/1.0/required_error)
+
+  if [[ $error == "" ]]; then
+    echo "error: No required error message specified for $package."
+    echo "$output" | while read line; do echo "test output: $line"; done
+    exit 1
+  fi
+
+  if [ $command_fails -ne 1 ]; then
+    echo "error: $package test did not fail"
+    exit 1
+  fi
+
+  if [[ $output != *$error* ]]; then
+    echo "error: error output for $package does not contain '$error':"
+    echo "$output" | while read line; do echo "test output: $line"; done
+    exit 1
+  fi
+
+done
diff --git a/test/error_test/no_interface_in_types/error/1.0/IFoo.hal b/test/error_test/interface_extends_only_interface/1.0/IFoo.hal
similarity index 84%
copy from test/error_test/no_interface_in_types/error/1.0/IFoo.hal
copy to test/error_test/interface_extends_only_interface/1.0/IFoo.hal
index d79e6ab..6b18b73 100644
--- a/test/error_test/no_interface_in_types/error/1.0/IFoo.hal
+++ b/test/error_test/interface_extends_only_interface/1.0/IFoo.hal
@@ -13,7 +13,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-package test.error.error@1.0;
+package test.interface_extends_only_interface@1.0;
 
-interface IFoo {
-};
\ No newline at end of file
+interface IFoo extends IStruct /* struct, not interface */ {
+};
diff --git a/test/error_test/interface_extends_only_interface/1.0/required_error b/test/error_test/interface_extends_only_interface/1.0/required_error
new file mode 100644
index 0000000..718544b
--- /dev/null
+++ b/test/error_test/interface_extends_only_interface/1.0/required_error
@@ -0,0 +1 @@
+You can only extend interfaces
\ No newline at end of file
diff --git a/test/error_test/no_interface_in_types/error/1.0/IFoo.hal b/test/error_test/interface_extends_only_interface/1.0/types.hal
similarity index 89%
copy from test/error_test/no_interface_in_types/error/1.0/IFoo.hal
copy to test/error_test/interface_extends_only_interface/1.0/types.hal
index d79e6ab..dffd41e 100644
--- a/test/error_test/no_interface_in_types/error/1.0/IFoo.hal
+++ b/test/error_test/interface_extends_only_interface/1.0/types.hal
@@ -13,7 +13,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-package test.error.error@1.0;
+package test.interface_extends_only_interface@1.0;
 
-interface IFoo {
-};
\ No newline at end of file
+struct IStruct {
+};
diff --git a/test/error_test/no_interface_in_types/error/1.0/IFoo.hal b/test/error_test/interface_no_using_reserved_method_names/1.0/IFoo.hal
similarity index 85%
copy from test/error_test/no_interface_in_types/error/1.0/IFoo.hal
copy to test/error_test/interface_no_using_reserved_method_names/1.0/IFoo.hal
index d79e6ab..9b68217 100644
--- a/test/error_test/no_interface_in_types/error/1.0/IFoo.hal
+++ b/test/error_test/interface_no_using_reserved_method_names/1.0/IFoo.hal
@@ -13,7 +13,8 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-package test.error.error@1.0;
+package test.interface_no_using_reserved_method_names@1.0;
 
 interface IFoo {
-};
\ No newline at end of file
+    debug(); // duplicates reserved method name
+};
diff --git a/test/error_test/interface_no_using_reserved_method_names/1.0/required_error b/test/error_test/interface_no_using_reserved_method_names/1.0/required_error
new file mode 100644
index 0000000..ec1dc30
--- /dev/null
+++ b/test/error_test/interface_no_using_reserved_method_names/1.0/required_error
@@ -0,0 +1 @@
+Redefinition of reserved method 'debug'
\ No newline at end of file
diff --git a/test/error_test/interface_semicolon/error/1.0/IFoo.hal b/test/error_test/interface_semicolon/1.0/IFoo.hal
similarity index 94%
rename from test/error_test/interface_semicolon/error/1.0/IFoo.hal
rename to test/error_test/interface_semicolon/1.0/IFoo.hal
index 8222665..f334052 100644
--- a/test/error_test/interface_semicolon/error/1.0/IFoo.hal
+++ b/test/error_test/interface_semicolon/1.0/IFoo.hal
@@ -13,7 +13,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-package test.error.error@1.0;
+package test.interface_semicolon@1.0;
 
 interface IFoo {
-} // <- missing semicolon
\ No newline at end of file
+} // <- missing semicolon
diff --git a/test/error_test/interface_semicolon/1.0/required_error b/test/error_test/interface_semicolon/1.0/required_error
new file mode 100644
index 0000000..4301bae
--- /dev/null
+++ b/test/error_test/interface_semicolon/1.0/required_error
@@ -0,0 +1 @@
+missing ; at
\ No newline at end of file
diff --git a/test/error_test/no_interface_in_types/error/1.0/IFoo.hal b/test/error_test/interface_unique_method_names/1.0/IFoo.hal
similarity index 83%
copy from test/error_test/no_interface_in_types/error/1.0/IFoo.hal
copy to test/error_test/interface_unique_method_names/1.0/IFoo.hal
index d79e6ab..9a39b97 100644
--- a/test/error_test/no_interface_in_types/error/1.0/IFoo.hal
+++ b/test/error_test/interface_unique_method_names/1.0/IFoo.hal
@@ -13,7 +13,9 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-package test.error.error@1.0;
+package test.interface_unique_method_names@1.0;
 
 interface IFoo {
-};
\ No newline at end of file
+    foo(int32_t arg);
+    foo(IFoo arg); // duplicates first method name
+};
diff --git a/test/error_test/interface_unique_method_names/1.0/required_error b/test/error_test/interface_unique_method_names/1.0/required_error
new file mode 100644
index 0000000..42c134b
--- /dev/null
+++ b/test/error_test/interface_unique_method_names/1.0/required_error
@@ -0,0 +1 @@
+Redefinition of method 'foo' at
\ No newline at end of file
diff --git a/test/error_test/no_interface_in_types/error/1.0/types.hal b/test/error_test/interface_unique_method_names_inheritance/1.0/IBar.hal
similarity index 87%
copy from test/error_test/no_interface_in_types/error/1.0/types.hal
copy to test/error_test/interface_unique_method_names_inheritance/1.0/IBar.hal
index a246ef8..25ac710 100644
--- a/test/error_test/no_interface_in_types/error/1.0/types.hal
+++ b/test/error_test/interface_unique_method_names_inheritance/1.0/IBar.hal
@@ -13,8 +13,8 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-package test.error.error@1.0;
+package test.interface_unique_method_names_inheritance@1.0;
 
-// can't have interface in types file
 interface IBar {
-};
\ No newline at end of file
+    foo(int32_t arg);
+};
diff --git a/test/error_test/no_interface_in_types/error/1.0/IFoo.hal b/test/error_test/interface_unique_method_names_inheritance/1.0/IFoo.hal
similarity index 78%
copy from test/error_test/no_interface_in_types/error/1.0/IFoo.hal
copy to test/error_test/interface_unique_method_names_inheritance/1.0/IFoo.hal
index d79e6ab..6e47cef 100644
--- a/test/error_test/no_interface_in_types/error/1.0/IFoo.hal
+++ b/test/error_test/interface_unique_method_names_inheritance/1.0/IFoo.hal
@@ -13,7 +13,10 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-package test.error.error@1.0;
+package test.interface_unique_method_names_inheritance@1.0;
 
-interface IFoo {
-};
\ No newline at end of file
+import IBar;
+
+interface IFoo extends IBar {
+    foo(IFoo arg); // duplicates method defined in IBar name
+};
diff --git a/test/error_test/interface_unique_method_names_inheritance/1.0/required_error b/test/error_test/interface_unique_method_names_inheritance/1.0/required_error
new file mode 100644
index 0000000..a76d410
--- /dev/null
+++ b/test/error_test/interface_unique_method_names_inheritance/1.0/required_error
@@ -0,0 +1 @@
+Redefinition of method 'foo'
\ No newline at end of file
diff --git a/test/error_test/method_ends_in_semicolon/error/1.0/IFoo.hal b/test/error_test/method_ends_in_semicolon/1.0/IFoo.hal
similarity index 93%
rename from test/error_test/method_ends_in_semicolon/error/1.0/IFoo.hal
rename to test/error_test/method_ends_in_semicolon/1.0/IFoo.hal
index e8ebca6..1814314 100644
--- a/test/error_test/method_ends_in_semicolon/error/1.0/IFoo.hal
+++ b/test/error_test/method_ends_in_semicolon/1.0/IFoo.hal
@@ -13,8 +13,8 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-package test.error.error@1.0;
+package test.method_ends_in_semicolon@1.0;
 
 interface IFoo {
     foo() generates (int32_t bar)
-};
\ No newline at end of file
+};
diff --git a/test/error_test/method_ends_in_semicolon/1.0/required_error b/test/error_test/method_ends_in_semicolon/1.0/required_error
new file mode 100644
index 0000000..4301bae
--- /dev/null
+++ b/test/error_test/method_ends_in_semicolon/1.0/required_error
@@ -0,0 +1 @@
+missing ; at
\ No newline at end of file
diff --git a/test/error_test/no_interface_in_types/error/1.0/IFoo.hal b/test/error_test/missing_variable_type/1.0/IFoo.hal
similarity index 85%
copy from test/error_test/no_interface_in_types/error/1.0/IFoo.hal
copy to test/error_test/missing_variable_type/1.0/IFoo.hal
index d79e6ab..b73bc84 100644
--- a/test/error_test/no_interface_in_types/error/1.0/IFoo.hal
+++ b/test/error_test/missing_variable_type/1.0/IFoo.hal
@@ -13,7 +13,9 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-package test.error.error@1.0;
+package test.missing_variable_type@1.0;
 
 interface IFoo {
-};
\ No newline at end of file
+    struct Struct { uint32_t a; };
+    foo() generates (Struct);
+};
diff --git a/test/error_test/missing_variable_type/1.0/required_error b/test/error_test/missing_variable_type/1.0/required_error
new file mode 100644
index 0000000..54573c6
--- /dev/null
+++ b/test/error_test/missing_variable_type/1.0/required_error
@@ -0,0 +1 @@
+is missing a variable name
\ No newline at end of file
diff --git a/test/error_test/no_interface_in_types/error/1.0/IFoo.hal b/test/error_test/no_cyclic_declaration_1/1.0/IFoo.hal
similarity index 86%
copy from test/error_test/no_interface_in_types/error/1.0/IFoo.hal
copy to test/error_test/no_cyclic_declaration_1/1.0/IFoo.hal
index d79e6ab..80b4938 100644
--- a/test/error_test/no_interface_in_types/error/1.0/IFoo.hal
+++ b/test/error_test/no_cyclic_declaration_1/1.0/IFoo.hal
@@ -13,7 +13,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-package test.error.error@1.0;
+package test.no_cyclic_declaration_1@1.0;
 
-interface IFoo {
-};
\ No newline at end of file
+interface IFoo extends IFoo /* extends itself */ {
+};
diff --git a/test/error_test/no_cyclic_declaration_1/1.0/required_error b/test/error_test/no_cyclic_declaration_1/1.0/required_error
new file mode 100644
index 0000000..340a6a5
--- /dev/null
+++ b/test/error_test/no_cyclic_declaration_1/1.0/required_error
@@ -0,0 +1 @@
+Cyclic declaration
\ No newline at end of file
diff --git a/test/error_test/no_interface_in_types/error/1.0/IFoo.hal b/test/error_test/no_cyclic_declaration_2/1.0/IFoo.hal
similarity index 84%
copy from test/error_test/no_interface_in_types/error/1.0/IFoo.hal
copy to test/error_test/no_cyclic_declaration_2/1.0/IFoo.hal
index d79e6ab..9477305 100644
--- a/test/error_test/no_interface_in_types/error/1.0/IFoo.hal
+++ b/test/error_test/no_cyclic_declaration_2/1.0/IFoo.hal
@@ -13,7 +13,13 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-package test.error.error@1.0;
+package test.no_cyclic_declaration_2@1.0;
 
 interface IFoo {
-};
\ No newline at end of file
+    struct A {
+        B b;
+    };
+    struct B {
+        A a;
+    };
+};
diff --git a/test/error_test/no_cyclic_declaration_2/1.0/required_error b/test/error_test/no_cyclic_declaration_2/1.0/required_error
new file mode 100644
index 0000000..340a6a5
--- /dev/null
+++ b/test/error_test/no_cyclic_declaration_2/1.0/required_error
@@ -0,0 +1 @@
+Cyclic declaration
\ No newline at end of file
diff --git a/test/error_test/no_cyclic_declaration_3/1.0/required_error b/test/error_test/no_cyclic_declaration_3/1.0/required_error
new file mode 100644
index 0000000..340a6a5
--- /dev/null
+++ b/test/error_test/no_cyclic_declaration_3/1.0/required_error
@@ -0,0 +1 @@
+Cyclic declaration
\ No newline at end of file
diff --git a/test/error_test/no_interface_in_types/error/1.0/IFoo.hal b/test/error_test/no_cyclic_declaration_3/1.0/types.hal
similarity index 89%
copy from test/error_test/no_interface_in_types/error/1.0/IFoo.hal
copy to test/error_test/no_cyclic_declaration_3/1.0/types.hal
index d79e6ab..3f78c51 100644
--- a/test/error_test/no_interface_in_types/error/1.0/IFoo.hal
+++ b/test/error_test/no_cyclic_declaration_3/1.0/types.hal
@@ -13,7 +13,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-package test.error.error@1.0;
+package test.no_cyclic_declaration_3@1.0;
 
-interface IFoo {
-};
\ No newline at end of file
+typedef A B;
+typedef B A;
diff --git a/test/error_test/no_cyclic_declaration_4/1.0/required_error b/test/error_test/no_cyclic_declaration_4/1.0/required_error
new file mode 100644
index 0000000..340a6a5
--- /dev/null
+++ b/test/error_test/no_cyclic_declaration_4/1.0/required_error
@@ -0,0 +1 @@
+Cyclic declaration
\ No newline at end of file
diff --git a/test/error_test/no_interface_in_types/error/1.0/IFoo.hal b/test/error_test/no_cyclic_declaration_4/1.0/types.hal
similarity index 88%
copy from test/error_test/no_interface_in_types/error/1.0/IFoo.hal
copy to test/error_test/no_cyclic_declaration_4/1.0/types.hal
index d79e6ab..32a7683 100644
--- a/test/error_test/no_interface_in_types/error/1.0/IFoo.hal
+++ b/test/error_test/no_cyclic_declaration_4/1.0/types.hal
@@ -13,7 +13,9 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-package test.error.error@1.0;
+package test.no_cyclic_declaration_4@1.0;
 
-interface IFoo {
-};
\ No newline at end of file
+typedef S SS;
+struct S {
+    SS foo;
+};
diff --git a/test/error_test/no_cyclic_expressions_1/1.0/required_error b/test/error_test/no_cyclic_expressions_1/1.0/required_error
new file mode 100644
index 0000000..340a6a5
--- /dev/null
+++ b/test/error_test/no_cyclic_expressions_1/1.0/required_error
@@ -0,0 +1 @@
+Cyclic declaration
\ No newline at end of file
diff --git a/test/error_test/no_interface_in_types/error/1.0/IFoo.hal b/test/error_test/no_cyclic_expressions_1/1.0/types.hal
similarity index 86%
copy from test/error_test/no_interface_in_types/error/1.0/IFoo.hal
copy to test/error_test/no_cyclic_expressions_1/1.0/types.hal
index d79e6ab..e46a150 100644
--- a/test/error_test/no_interface_in_types/error/1.0/IFoo.hal
+++ b/test/error_test/no_cyclic_expressions_1/1.0/types.hal
@@ -13,7 +13,11 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-package test.error.error@1.0;
+package test.no_cyclic_expressions_1@1.0;
 
-interface IFoo {
-};
\ No newline at end of file
+enum E : int32_t {
+    A = D,
+    B,
+    C,
+    D
+};
diff --git a/test/error_test/no_cyclic_expressions_2/1.0/required_error b/test/error_test/no_cyclic_expressions_2/1.0/required_error
new file mode 100644
index 0000000..340a6a5
--- /dev/null
+++ b/test/error_test/no_cyclic_expressions_2/1.0/required_error
@@ -0,0 +1 @@
+Cyclic declaration
\ No newline at end of file
diff --git a/test/error_test/no_interface_in_types/error/1.0/IFoo.hal b/test/error_test/no_cyclic_expressions_2/1.0/types.hal
similarity index 84%
copy from test/error_test/no_interface_in_types/error/1.0/IFoo.hal
copy to test/error_test/no_cyclic_expressions_2/1.0/types.hal
index d79e6ab..e67a774 100644
--- a/test/error_test/no_interface_in_types/error/1.0/IFoo.hal
+++ b/test/error_test/no_cyclic_expressions_2/1.0/types.hal
@@ -13,7 +13,14 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-package test.error.error@1.0;
+package test.no_cyclic_expressions_2@1.0;
 
-interface IFoo {
-};
\ No newline at end of file
+enum X : int32_t {
+    A = Y:D,
+    B,
+};
+
+enum Y : X {
+    C,
+    D,
+};
diff --git a/test/error_test/no_cyclic_expressions_3/1.0/required_error b/test/error_test/no_cyclic_expressions_3/1.0/required_error
new file mode 100644
index 0000000..340a6a5
--- /dev/null
+++ b/test/error_test/no_cyclic_expressions_3/1.0/required_error
@@ -0,0 +1 @@
+Cyclic declaration
\ No newline at end of file
diff --git a/test/error_test/no_interface_in_types/error/1.0/IFoo.hal b/test/error_test/no_cyclic_expressions_3/1.0/types.hal
similarity index 89%
copy from test/error_test/no_interface_in_types/error/1.0/IFoo.hal
copy to test/error_test/no_cyclic_expressions_3/1.0/types.hal
index d79e6ab..c544609 100644
--- a/test/error_test/no_interface_in_types/error/1.0/IFoo.hal
+++ b/test/error_test/no_cyclic_expressions_3/1.0/types.hal
@@ -13,7 +13,8 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-package test.error.error@1.0;
+package test.no_cyclic_expressions_3@1.0;
 
-interface IFoo {
-};
\ No newline at end of file
+enum E : int32_t {
+    A = A
+};
diff --git a/test/error_test/no_data_outside_interface/error/1.0/IFoo.hal b/test/error_test/no_data_outside_interface/1.0/IFoo.hal
similarity index 93%
rename from test/error_test/no_data_outside_interface/error/1.0/IFoo.hal
rename to test/error_test/no_data_outside_interface/1.0/IFoo.hal
index 4a5ab96..73681b2 100644
--- a/test/error_test/no_data_outside_interface/error/1.0/IFoo.hal
+++ b/test/error_test/no_data_outside_interface/1.0/IFoo.hal
@@ -13,10 +13,10 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-package test.error.error@1.0;
+package test.no_data_outside_interface@1.0;
 
 struct Bar { // can only have this in types.hal files
 };
 
 interface IFoo {
-};
\ No newline at end of file
+};
diff --git a/test/error_test/no_data_outside_interface/1.0/required_error b/test/error_test/no_data_outside_interface/1.0/required_error
new file mode 100644
index 0000000..497ccd4
--- /dev/null
+++ b/test/error_test/no_data_outside_interface/1.0/required_error
@@ -0,0 +1 @@
+declares types rather than the expected interface type 'IFoo'
\ No newline at end of file
diff --git a/test/error_test/no_interface_in_types/error/1.0/IFoo.hal b/test/error_test/no_interface_in_types/1.0/IFoo.hal
similarity index 93%
copy from test/error_test/no_interface_in_types/error/1.0/IFoo.hal
copy to test/error_test/no_interface_in_types/1.0/IFoo.hal
index d79e6ab..a994968 100644
--- a/test/error_test/no_interface_in_types/error/1.0/IFoo.hal
+++ b/test/error_test/no_interface_in_types/1.0/IFoo.hal
@@ -13,7 +13,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-package test.error.error@1.0;
+package test.no_interface_in_types@1.0;
 
 interface IFoo {
-};
\ No newline at end of file
+};
diff --git a/test/error_test/no_interface_in_types/1.0/required_error b/test/error_test/no_interface_in_types/1.0/required_error
new file mode 100644
index 0000000..3fe7eaf
--- /dev/null
+++ b/test/error_test/no_interface_in_types/1.0/required_error
@@ -0,0 +1 @@
+declares an interface 'IBar' instead of the expected types common to the package
\ No newline at end of file
diff --git a/test/error_test/no_interface_in_types/error/1.0/types.hal b/test/error_test/no_interface_in_types/1.0/types.hal
similarity index 94%
rename from test/error_test/no_interface_in_types/error/1.0/types.hal
rename to test/error_test/no_interface_in_types/1.0/types.hal
index a246ef8..a2c49f8 100644
--- a/test/error_test/no_interface_in_types/error/1.0/types.hal
+++ b/test/error_test/no_interface_in_types/1.0/types.hal
@@ -13,8 +13,8 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-package test.error.error@1.0;
+package test.no_interface_in_types@1.0;
 
 // can't have interface in types file
 interface IBar {
-};
\ No newline at end of file
+};
diff --git a/test/error_test/no_interface_in_types/error/1.0/IFoo.hal b/test/error_test/no_two_interfaces/1.0/IFoo.hal
similarity index 91%
copy from test/error_test/no_interface_in_types/error/1.0/IFoo.hal
copy to test/error_test/no_two_interfaces/1.0/IFoo.hal
index d79e6ab..eb416d3 100644
--- a/test/error_test/no_interface_in_types/error/1.0/IFoo.hal
+++ b/test/error_test/no_two_interfaces/1.0/IFoo.hal
@@ -13,7 +13,10 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-package test.error.error@1.0;
+package test.no_two_interfaces@1.0;
 
 interface IFoo {
-};
\ No newline at end of file
+};
+
+interface IBar {
+};
diff --git a/test/error_test/no_two_interfaces/1.0/required_error b/test/error_test/no_two_interfaces/1.0/required_error
new file mode 100644
index 0000000..497ccd4
--- /dev/null
+++ b/test/error_test/no_two_interfaces/1.0/required_error
@@ -0,0 +1 @@
+declares types rather than the expected interface type 'IFoo'
\ No newline at end of file
diff --git a/test/error_test/no_two_interfaces/error/1.0/IFoo.hal b/test/error_test/no_two_interfaces/error/1.0/IFoo.hal
deleted file mode 100644
index db27507..0000000
--- a/test/error_test/no_two_interfaces/error/1.0/IFoo.hal
+++ /dev/null
@@ -1,23 +0,0 @@
-/*
- * Copyright (C) 2017 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.
- */
-package test.error.error@1.0;
-
-interface IFoo {
-};
-
-// can only have one interface per file
-interface IBar {
-};
\ No newline at end of file
diff --git a/test/error_test/same_name_interface/error/1.0/IFoo.hal b/test/error_test/references_broken_package/1.0/IBar.hal
similarity index 78%
copy from test/error_test/same_name_interface/error/1.0/IFoo.hal
copy to test/error_test/references_broken_package/1.0/IBar.hal
index df7806c..27dbdeb 100644
--- a/test/error_test/same_name_interface/error/1.0/IFoo.hal
+++ b/test/error_test/references_broken_package/1.0/IBar.hal
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2017 The Android Open Source Project
+ * Copyright (C) 2018 The Android Open Source Project
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -13,8 +13,9 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-package test.error.error@1.0;
+package test.references_broken_package@1.0;
 
-// Must be called IFoo
+import test.references_broken_package.bad_package@1.0::IFoo;
+
 interface IBar {
-};
\ No newline at end of file
+};
diff --git a/test/error_test/references_broken_package/1.0/required_error b/test/error_test/references_broken_package/1.0/required_error
new file mode 100644
index 0000000..4301bae
--- /dev/null
+++ b/test/error_test/references_broken_package/1.0/required_error
@@ -0,0 +1 @@
+missing ; at
\ No newline at end of file
diff --git a/test/error_test/no_interface_in_types/error/1.0/IFoo.hal b/test/error_test/references_broken_package/bad_package/1.0/IFoo.hal
similarity index 80%
copy from test/error_test/no_interface_in_types/error/1.0/IFoo.hal
copy to test/error_test/references_broken_package/bad_package/1.0/IFoo.hal
index d79e6ab..14d4189 100644
--- a/test/error_test/no_interface_in_types/error/1.0/IFoo.hal
+++ b/test/error_test/references_broken_package/bad_package/1.0/IFoo.hal
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2017 The Android Open Source Project
+ * Copyright (C) 2018 The Android Open Source Project
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -13,7 +13,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-package test.error.error@1.0;
+package test.references_broken_package.bad_package@1.0;
 
 interface IFoo {
-};
\ No newline at end of file
+} // no semicolon -> error
diff --git a/test/error_test/no_interface_in_types/error/1.0/IFoo.hal b/test/error_test/references_broken_package/bad_package/1.0/types.hal
similarity index 81%
copy from test/error_test/no_interface_in_types/error/1.0/IFoo.hal
copy to test/error_test/references_broken_package/bad_package/1.0/types.hal
index d79e6ab..ea7ed6e 100644
--- a/test/error_test/no_interface_in_types/error/1.0/IFoo.hal
+++ b/test/error_test/references_broken_package/bad_package/1.0/types.hal
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2017 The Android Open Source Project
+ * Copyright (C) 2018 The Android Open Source Project
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -13,7 +13,6 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-package test.error.error@1.0;
+package test.references_broken_package.bad_package@1.0;
 
-interface IFoo {
-};
\ No newline at end of file
+struct IFoo {};
\ No newline at end of file
diff --git a/test/error_test/same_name_interface/error/1.0/IFoo.hal b/test/error_test/same_name_interface/1.0/IFoo.hal
similarity index 94%
rename from test/error_test/same_name_interface/error/1.0/IFoo.hal
rename to test/error_test/same_name_interface/1.0/IFoo.hal
index df7806c..71a0671 100644
--- a/test/error_test/same_name_interface/error/1.0/IFoo.hal
+++ b/test/error_test/same_name_interface/1.0/IFoo.hal
@@ -13,8 +13,8 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-package test.error.error@1.0;
+package test.same_name_interface@1.0;
 
 // Must be called IFoo
 interface IBar {
-};
\ No newline at end of file
+};
diff --git a/test/error_test/same_name_interface/1.0/required_error b/test/error_test/same_name_interface/1.0/required_error
new file mode 100644
index 0000000..1a46ce9
--- /dev/null
+++ b/test/error_test/same_name_interface/1.0/required_error
@@ -0,0 +1 @@
+does not declare interface type 'IFoo'
\ No newline at end of file
diff --git a/test/error_test/no_interface_in_types/error/1.0/IFoo.hal b/test/error_test/same_package_name/1.0/IFoo.hal
similarity index 95%
rename from test/error_test/no_interface_in_types/error/1.0/IFoo.hal
rename to test/error_test/same_package_name/1.0/IFoo.hal
index d79e6ab..60702d9 100644
--- a/test/error_test/no_interface_in_types/error/1.0/IFoo.hal
+++ b/test/error_test/same_package_name/1.0/IFoo.hal
@@ -13,7 +13,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-package test.error.error@1.0;
+package test.notpackage@1.0;
 
 interface IFoo {
-};
\ No newline at end of file
+};
diff --git a/test/error_test/same_package_name/1.0/required_error b/test/error_test/same_package_name/1.0/required_error
new file mode 100644
index 0000000..d18a773
--- /dev/null
+++ b/test/error_test/same_package_name/1.0/required_error
@@ -0,0 +1 @@
+does not match expected package and/or version
\ No newline at end of file
diff --git a/test/error_test/same_package_name/error/1.0/IFoo.hal b/test/error_test/same_package_name/error/1.0/IFoo.hal
deleted file mode 100644
index efc71b2..0000000
--- a/test/error_test/same_package_name/error/1.0/IFoo.hal
+++ /dev/null
@@ -1,19 +0,0 @@
-/*
- * Copyright (C) 2017 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.
- */
-package test.error.notpackage@1.0;
-
-interface IFoo {
-};
\ No newline at end of file
diff --git a/test/error_test/no_interface_in_types/error/1.0/IFoo.hal b/test/error_test/scope_unique_type_names/1.0/IFoo.hal
similarity index 84%
copy from test/error_test/no_interface_in_types/error/1.0/IFoo.hal
copy to test/error_test/scope_unique_type_names/1.0/IFoo.hal
index d79e6ab..815c8a2 100644
--- a/test/error_test/no_interface_in_types/error/1.0/IFoo.hal
+++ b/test/error_test/scope_unique_type_names/1.0/IFoo.hal
@@ -13,7 +13,9 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-package test.error.error@1.0;
+package test.scope_unique_type_names@1.0;
 
 interface IFoo {
-};
\ No newline at end of file
+    struct S {};
+    enum S : int32_t {};  // duplicates first struct name
+};
diff --git a/test/error_test/scope_unique_type_names/1.0/required_error b/test/error_test/scope_unique_type_names/1.0/required_error
new file mode 100644
index 0000000..f876888
--- /dev/null
+++ b/test/error_test/scope_unique_type_names/1.0/required_error
@@ -0,0 +1 @@
+A type named 'S' is already declared in the scope at
\ No newline at end of file
diff --git a/test/error_test/no_interface_in_types/error/1.0/IFoo.hal b/test/error_test/struct_unique_field_names/1.0/IFoo.hal
similarity index 82%
copy from test/error_test/no_interface_in_types/error/1.0/IFoo.hal
copy to test/error_test/struct_unique_field_names/1.0/IFoo.hal
index d79e6ab..d5c07cd 100644
--- a/test/error_test/no_interface_in_types/error/1.0/IFoo.hal
+++ b/test/error_test/struct_unique_field_names/1.0/IFoo.hal
@@ -13,7 +13,11 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-package test.error.error@1.0;
+package test.struct_unique_field_names@1.0;
 
 interface IFoo {
-};
\ No newline at end of file
+    struct S {
+        int32_t a;
+        int32_t a;  // duplicates first field name
+    };
+};
diff --git a/test/error_test/struct_unique_field_names/1.0/required_error b/test/error_test/struct_unique_field_names/1.0/required_error
new file mode 100644
index 0000000..0aca5dc
--- /dev/null
+++ b/test/error_test/struct_unique_field_names/1.0/required_error
@@ -0,0 +1 @@
+Redefinition of field 'a'
\ No newline at end of file
diff --git a/test/error_test/no_interface_in_types/error/1.0/IFoo.hal b/test/export_test/1.0/IFoo.hal
similarity index 86%
copy from test/error_test/no_interface_in_types/error/1.0/IFoo.hal
copy to test/export_test/1.0/IFoo.hal
index d79e6ab..adde1da 100644
--- a/test/error_test/no_interface_in_types/error/1.0/IFoo.hal
+++ b/test/export_test/1.0/IFoo.hal
@@ -13,7 +13,13 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-package test.error.error@1.0;
+package export@1.0;
 
 interface IFoo {
+    @export
+    enum S : uint32_t {
+        X,
+        Y,
+        Z,
+    };
 };
\ No newline at end of file
diff --git a/test/error_test/no_interface_in_types/error/1.0/IFoo.hal b/test/export_test/1.0/types.hal
similarity index 69%
copy from test/error_test/no_interface_in_types/error/1.0/IFoo.hal
copy to test/export_test/1.0/types.hal
index d79e6ab..d58d097 100644
--- a/test/error_test/no_interface_in_types/error/1.0/IFoo.hal
+++ b/test/export_test/1.0/types.hal
@@ -13,7 +13,24 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-package test.error.error@1.0;
+package export@1.0;
 
-interface IFoo {
+@export
+enum NoArgs : uint32_t {
+    A = 1,
+};
+
+@export(name="")
+enum NoName : uint32_t {
+    B = 2,
+};
+
+@export(value_prefix="prefix")
+enum ValueSuffix : uint32_t {
+    C = 3,
+};
+
+@export(value_suffix="suffix")
+enum ValuePrefix : uint32_t {
+    D = 4,
 };
\ No newline at end of file
diff --git a/test/export_test/Android.bp b/test/export_test/Android.bp
new file mode 100644
index 0000000..5d7bead
--- /dev/null
+++ b/test/export_test/Android.bp
@@ -0,0 +1,22 @@
+genrule {
+    name: "hidl_export_test_gen-headers",
+    tools: [
+        "hidl-gen",
+    ],
+    srcs: [
+        "1.0/IFoo.hal",
+        "1.0/types.hal"
+    ],
+    cmd: "$(location hidl-gen) -o $(genDir)/export-base.h -Lexport-header " +
+         "-rexport:system/tools/hidl/test/export_test export@1.0",
+    out: [
+        "export-base.h"
+    ],
+}
+
+cc_test_library {
+    name: "hidl_export_test",
+    cflags: ["-Wall", "-Werror"],
+    generated_headers: ["hidl_export_test_gen-headers"],
+    srcs: ["test.cpp"],
+}
diff --git a/test/error_test/no_interface_in_types/error/1.0/IFoo.hal b/test/export_test/test.cpp
similarity index 60%
copy from test/error_test/no_interface_in_types/error/1.0/IFoo.hal
copy to test/export_test/test.cpp
index d79e6ab..91cebff 100644
--- a/test/error_test/no_interface_in_types/error/1.0/IFoo.hal
+++ b/test/export_test/test.cpp
@@ -13,7 +13,24 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-package test.error.error@1.0;
 
-interface IFoo {
-};
\ No newline at end of file
+#include <export-base.h>
+
+// From IFoo.hal
+
+static_assert(X == 0, "");
+static_assert(Y == 1, "");
+static_assert(Z == 2, "");
+
+typedef S SExists;
+
+// From types.hal
+
+static_assert(B == 2, "");
+enum NoName {};  // causes error if declared already
+
+static_assert(prefixC == 3, "");
+typedef ValueSuffix ValueSuffixExists;
+
+static_assert(Dsuffix == 4, "");
+typedef ValuePrefix ValuePrefixExists;
diff --git a/test/hash_test/Android.bp b/test/hash_test/Android.bp
index 89c403b..5f9f248 100644
--- a/test/hash_test/Android.bp
+++ b/test/hash_test/Android.bp
@@ -31,5 +31,6 @@
 
 cc_test_host {
     name: "hidl_hash_test",
+    cflags: ["-Wall", "-Werror"],
     generated_sources: ["hidl_hash_test_gen"],
 }
diff --git a/test/hash_test/good/current.txt b/test/hash_test/good/current.txt
index b6e7514..ff4b669 100644
--- a/test/hash_test/good/current.txt
+++ b/test/hash_test/good/current.txt
@@ -1 +1 @@
-b19939ecb4f877820df49b684f3164f0a3f9aa18743a3521f3bd04e4a06fed64 test.hash.hash@1.0::IHash
+b19939ecb4f877820df49b684f3164f0a3f9aa18743a3521f3bd04e4a06fed64 test.hash.hash@1.0::IHash # comments are fine too
diff --git a/test/hidl_test.h b/test/hidl_test.h
deleted file mode 100644
index 3eeebaf..0000000
--- a/test/hidl_test.h
+++ /dev/null
@@ -1,17 +0,0 @@
-#ifndef HIDL_TEST_H_
-#define HIDL_TEST_H_
-
-#define EACH_SERVER(THING)                  \
-    do {                                    \
-        THING<IMemoryTest>("memory");       \
-        THING<IChild>("child");             \
-        THING<IParent>("parent");           \
-        THING<IFetcher>("fetcher");         \
-        THING<IBar>("foo");                 \
-        THING<IHash>("default");            \
-        THING<IGraph>("graph");             \
-        THING<IPointer>("pointer");         \
-        THING<IMultithread>("multithread"); \
-    } while (false)
-
-#endif  // HIDL_TEST_H_
\ No newline at end of file
diff --git a/test/hidl_test/Android.bp b/test/hidl_test/Android.bp
new file mode 100644
index 0000000..73110a6
--- /dev/null
+++ b/test/hidl_test/Android.bp
@@ -0,0 +1,77 @@
+cc_defaults {
+    name: "hidl_test_client-defaults",
+    defaults: ["hidl-gen-defaults"],
+
+    shared_libs: [
+        "android.hidl.memory@1.0",
+        "android.hidl.memory.token@1.0",
+        "android.hidl.token@1.0",
+        "libbase",
+        "libcutils",
+        "libhidlbase",
+        "libhidlmemory",
+        "libhidltransport",
+        "libhwbinder",
+        "liblog",
+        "libutils",
+    ],
+
+    // Allow dlsym'ing self for statically linked passthrough implementations
+    ldflags: ["-rdynamic"],
+
+    // These are static libs only for testing purposes and portability. Shared
+    // libs should be used on device.
+    static_libs: [
+        "libfootest",
+        "libpointertest",
+        "android.hardware.tests.expression@1.0",
+        "android.hardware.tests.foo@1.0",
+        "android.hardware.tests.bar@1.0",
+        "android.hardware.tests.baz@1.0",
+        "android.hardware.tests.hash@1.0",
+        "android.hardware.tests.inheritance@1.0",
+        "android.hardware.tests.pointer@1.0",
+        "android.hardware.tests.memory@1.0",
+        "android.hardware.tests.multithread@1.0",
+        "android.hardware.tests.trie@1.0",
+    ],
+
+    // impls should never be static, these are used only for testing purposes
+    // and test portability since this test pairs with specific hal
+    // implementations
+    whole_static_libs: [
+        "android.hardware.tests.foo@1.0-impl",
+        "android.hardware.tests.bar@1.0-impl",
+        "android.hardware.tests.baz@1.0-impl",
+        "android.hardware.tests.hash@1.0-impl",
+        "android.hardware.tests.inheritance@1.0-impl",
+        "android.hardware.tests.pointer@1.0-impl",
+        "android.hardware.tests.memory@1.0-impl",
+        "android.hardware.tests.multithread@1.0-impl",
+        "android.hardware.tests.trie@1.0-impl",
+    ],
+
+    group_static_libs: true,
+}
+
+cc_test {
+    name: "hidl_test_client",
+    defaults: ["hidl_test_client-defaults"],
+
+    srcs: [
+        "hidl_test_client.cpp",
+        "FooCallback.cpp",
+        "static_test.cpp"
+    ],
+
+    shared_libs: [
+        "android.hidl.allocator@1.0",
+    ],
+}
+
+cc_test {
+    name: "hidl_test_servers",
+    defaults: ["hidl_test_client-defaults"],
+    srcs: ["hidl_test_servers.cpp"],
+    gtest: false,
+}
diff --git a/test/Android.mk b/test/hidl_test/Android.mk
similarity index 77%
rename from test/Android.mk
rename to test/hidl_test/Android.mk
index ff0001c..f328223 100644
--- a/test/Android.mk
+++ b/test/hidl_test/Android.mk
@@ -25,12 +25,15 @@
 LOCAL_MODULE := hidl_test
 LOCAL_MODULE_CLASS := NATIVE_TESTS
 LOCAL_SRC_FILES := hidl_test
-LOCAL_REQUIRED_MODULES :=                       \
-    hidl_test_client                            \
-    hidl_test_servers                           \
-    hidl_test_client_32                         \
-    hidl_test_servers_32                        \
-    hidl_test_helper
+
+LOCAL_REQUIRED_MODULES := \
+    hidl_test_client \
+    hidl_test_helper \
+    hidl_test_servers
+
+LOCAL_REQUIRED_MODULES_arm64 := hidl_test_servers_32 hidl_test_client_32
+LOCAL_REQUIRED_MODULES_mips64 := hidl_test_servers_32 hidl_test_client_32
+LOCAL_REQUIRED_MODULES_x86_64 := hidl_test_servers_32 hidl_test_client_32
 
 include $(BUILD_PREBUILT)
 
@@ -39,5 +42,3 @@
 LOCAL_MODULE := VtsHidlUnitTests
 VTS_CONFIG_SRC_DIR := system/tools/hidl/tests
 -include test/vts/tools/build/Android.host_config.mk
-
-include $(call all-makefiles-under,$(LOCAL_PATH))
diff --git a/test/hidl_test/AndroidTest.xml b/test/hidl_test/AndroidTest.xml
new file mode 100644
index 0000000..6633942
--- /dev/null
+++ b/test/hidl_test/AndroidTest.xml
@@ -0,0 +1,34 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- Copyright (C) 2016 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.
+-->
+<configuration description="Config for VTS HIDL unit tests">
+    <option name="config-descriptor:metadata" key="plan" value="vts-library" />
+    <target_preparer class="com.android.compatibility.common.tradefed.targetprep.VtsFilePusher">
+        <option name="push-group" value="HostDrivenTest.push" />
+        <option name="cleanup" value="true" />
+        <option name="push" value="DATA/nativetest/hidl_test_servers/hidl_test_servers->/data/nativetest/hidl_test_servers/hidl_test_servers" />
+        <option name="push" value="DATA/nativetest64/hidl_test_servers/hidl_test_servers->/data/nativetest64/hidl_test_servers/hidl_test_servers" />
+        <option name="push" value="DATA/nativetest/hidl_test_client/hidl_test_client->/data/nativetest/hidl_test_client/hidl_test_client" />
+        <option name="push" value="DATA/nativetest64/hidl_test_client/hidl_test_client->/data/nativetest64/hidl_test_client/hidl_test_client" />
+        <option name="push" value="DATA/nativetest64/hidl_test_helper->/data/nativetest64/hidl_test_helper" />
+    </target_preparer>
+    <multi_target_preparer class="com.android.tradefed.targetprep.VtsPythonVirtualenvPreparer" />
+    <test class="com.android.tradefed.testtype.VtsMultiDeviceTest">
+      <option name="test-module-name" value="VtsHidlUnitTests" />
+      <option name="binary-test-type" value="binary_test" />
+      <option name="binary-test-source" value="DATA/nativetest64/hidl_test->/data/nativetest64/hidl_test" />
+      <option name="test-timeout" value="1m" />
+    </test>
+</configuration>
diff --git a/test/FooCallback.cpp b/test/hidl_test/FooCallback.cpp
similarity index 100%
rename from test/FooCallback.cpp
rename to test/hidl_test/FooCallback.cpp
diff --git a/test/FooCallback.h b/test/hidl_test/FooCallback.h
similarity index 100%
rename from test/FooCallback.h
rename to test/hidl_test/FooCallback.h
diff --git a/test/hidl_test b/test/hidl_test/hidl_test
similarity index 100%
rename from test/hidl_test
rename to test/hidl_test/hidl_test
diff --git a/test/hidl_test/hidl_test.h b/test/hidl_test/hidl_test.h
new file mode 100644
index 0000000..0ad17ef
--- /dev/null
+++ b/test/hidl_test/hidl_test.h
@@ -0,0 +1,40 @@
+#ifndef HIDL_TEST_H_
+#define HIDL_TEST_H_
+
+#include <android/hardware/tests/bar/1.0/IBar.h>
+#include <android/hardware/tests/hash/1.0/IHash.h>
+#include <android/hardware/tests/inheritance/1.0/IChild.h>
+#include <android/hardware/tests/inheritance/1.0/IFetcher.h>
+#include <android/hardware/tests/inheritance/1.0/IParent.h>
+#include <android/hardware/tests/memory/1.0/IMemoryTest.h>
+#include <android/hardware/tests/multithread/1.0/IMultithread.h>
+#include <android/hardware/tests/pointer/1.0/IGraph.h>
+#include <android/hardware/tests/pointer/1.0/IPointer.h>
+#include <android/hardware/tests/trie/1.0/ITrie.h>
+
+template <template <typename Type> class Service>
+void runOnEachServer(void) {
+    using ::android::hardware::tests::bar::V1_0::IBar;
+    using ::android::hardware::tests::hash::V1_0::IHash;
+    using ::android::hardware::tests::inheritance::V1_0::IChild;
+    using ::android::hardware::tests::inheritance::V1_0::IFetcher;
+    using ::android::hardware::tests::inheritance::V1_0::IParent;
+    using ::android::hardware::tests::memory::V1_0::IMemoryTest;
+    using ::android::hardware::tests::multithread::V1_0::IMultithread;
+    using ::android::hardware::tests::pointer::V1_0::IGraph;
+    using ::android::hardware::tests::pointer::V1_0::IPointer;
+    using ::android::hardware::tests::trie::V1_0::ITrie;
+
+    Service<IMemoryTest>::run("memory");
+    Service<IChild>::run("child");
+    Service<IParent>::run("parent");
+    Service<IFetcher>::run("fetcher");
+    Service<IBar>::run("foo");
+    Service<IHash>::run("default");
+    Service<IGraph>::run("graph");
+    Service<IPointer>::run("pointer");
+    Service<IMultithread>::run("multithread");
+    Service<ITrie>::run("trie");
+}
+
+#endif  // HIDL_TEST_H_
diff --git a/test/hidl_test_client.cpp b/test/hidl_test/hidl_test_client.cpp
similarity index 80%
rename from test/hidl_test_client.cpp
rename to test/hidl_test/hidl_test_client.cpp
index a8e7793..718a32c 100644
--- a/test/hidl_test_client.cpp
+++ b/test/hidl_test/hidl_test_client.cpp
@@ -10,11 +10,11 @@
 
 #include <android/hidl/allocator/1.0/IAllocator.h>
 #include <android/hidl/memory/1.0/IMemory.h>
-
+#include <android/hidl/memory/token/1.0/IMemoryToken.h>
 #include <android/hidl/token/1.0/ITokenManager.h>
 
-#include <android/hardware/tests/bar/1.0/BpHwBar.h>
 #include <android/hardware/tests/bar/1.0/BnHwBar.h>
+#include <android/hardware/tests/bar/1.0/BpHwBar.h>
 #include <android/hardware/tests/bar/1.0/IBar.h>
 #include <android/hardware/tests/bar/1.0/IComplicated.h>
 #include <android/hardware/tests/bar/1.0/IImportRules.h>
@@ -32,6 +32,7 @@
 #include <android/hardware/tests/multithread/1.0/IMultithread.h>
 #include <android/hardware/tests/pointer/1.0/IGraph.h>
 #include <android/hardware/tests/pointer/1.0/IPointer.h>
+#include <android/hardware/tests/trie/1.0/ITrie.h>
 
 #include <gtest/gtest.h>
 #if GTEST_IS_THREADSAFE
@@ -51,9 +52,12 @@
 #include <fstream>
 #include <future>
 #include <mutex>
+#include <random>
 #include <set>
 #include <sstream>
 #include <thread>
+#include <type_traits>
+#include <unordered_set>
 #include <utility>
 #include <vector>
 
@@ -62,6 +66,7 @@
 
 #include <hidl/ServiceManagement.h>
 #include <hidl/Status.h>
+#include <hidlmemory/HidlMemoryToken.h>
 #include <hidlmemory/mapping.h>
 
 #include <utils/Condition.h>
@@ -102,11 +107,14 @@
 using ::android::hardware::tests::pointer::V1_0::IPointer;
 using ::android::hardware::tests::memory::V1_0::IMemoryTest;
 using ::android::hardware::tests::multithread::V1_0::IMultithread;
+using ::android::hardware::tests::trie::V1_0::ITrie;
+using ::android::hardware::tests::trie::V1_0::TrieNode;
 using ::android::hardware::Return;
 using ::android::hardware::Void;
 using ::android::hardware::hidl_array;
 using ::android::hardware::hidl_death_recipient;
 using ::android::hardware::hidl_memory;
+using ::android::hardware::HidlMemory;
 using ::android::hardware::hidl_string;
 using ::android::hardware::hidl_vec;
 using ::android::hidl::allocator::V1_0::IAllocator;
@@ -114,6 +122,8 @@
 using ::android::hidl::manager::V1_1::IServiceManager;
 using ::android::hidl::manager::V1_0::IServiceNotification;
 using ::android::hidl::memory::V1_0::IMemory;
+using ::android::hidl::memory::token::V1_0::IMemoryToken;
+using ::android::hidl::memory::block::V1_0::MemoryBlock;
 using ::android::hidl::token::V1_0::ITokenManager;
 using ::android::sp;
 using ::android::wp;
@@ -127,16 +137,8 @@
 using ::android::ONEWAY_TOLERANCE_NS;
 using std::to_string;
 
-bool isLibraryOpen(const std::string &lib) {
-    std::ifstream ifs("/proc/self/maps");
-    for (std::string line; std::getline(ifs, line);) {
-        if (line.size() >= lib.size() && line.substr(line.size() - lib.size()) == lib) {
-            return true;
-        }
-    }
-
-    return false;
-}
+template <typename T>
+using hidl_enum_iterator = ::android::hardware::hidl_enum_iterator<T>;
 
 template <typename T>
 static inline ::testing::AssertionResult isOk(const ::android::hardware::Return<T> &ret) {
@@ -268,67 +270,6 @@
     int32_t mCookie;
 };
 
-// Ensure (statically) that the types in IImportRules resolves to the correct types by
-// overriding the methods with fully namespaced types as arguments.
-struct MyImportRules : public ::android::hardware::tests::bar::V1_0::IImportRules {
-    Return<void> rule0a(
-            const ::android::hardware::tests::bar::V1_0::IImportRules::Outer&) override {
-        return Void();
-    }
-
-    Return<void> rule0a1(
-            const ::android::hardware::tests::bar::V1_0::IImportRules::Outer&) override {
-        return Void();
-    }
-
-    Return<void> rule0b(
-            const ::android::hardware::tests::bar::V1_0::IImportRules::Outer&) override {
-        return Void();
-    }
-
-    Return<void> rule0c(const ::android::hardware::tests::foo::V1_0::Outer&) override {
-        return Void();
-    }
-
-    Return<void> rule0d(const ::android::hardware::tests::foo::V1_0::Outer&) override {
-        return Void();
-    }
-
-    Return<void> rule0e(
-            const ::android::hardware::tests::bar::V1_0::IImportRules::Outer::Inner&) override {
-        return Void();
-    }
-
-    Return<void> rule0f(
-            const ::android::hardware::tests::bar::V1_0::IImportRules::Outer::Inner&) override {
-        return Void();
-    }
-
-    Return<void> rule0g(const ::android::hardware::tests::foo::V1_0::Outer::Inner&) override {
-        return Void();
-    }
-
-    Return<void> rule0h(const ::android::hardware::tests::foo::V1_0::Outer::Inner&) override {
-        return Void();
-    }
-
-    Return<void> rule1a(const ::android::hardware::tests::bar::V1_0::Def&) override {
-        return Void();
-    }
-
-    Return<void> rule1b(const ::android::hardware::tests::foo::V1_0::Def&) override {
-        return Void();
-    }
-
-    Return<void> rule2a(const ::android::hardware::tests::foo::V1_0::Unrelated&) override {
-        return Void();
-    }
-
-    Return<void> rule2b(const sp<::android::hardware::tests::foo::V1_0::IFooCallback>&) override {
-        return Void();
-    }
-};
-
 struct ServiceNotification : public IServiceNotification {
     std::mutex mutex;
     std::condition_variable condition;
@@ -373,6 +314,7 @@
     sp<IPointer> pointerInterface;
     sp<IPointer> validationPointerInterface;
     sp<IMultithread> multithreadInterface;
+    sp<ITrie> trieInterface;
     TestMode mode;
     bool enableDelayMeasurementTests;
     HidlEnvironment(TestMode mode, bool enableDelayMeasurementTests) :
@@ -434,6 +376,10 @@
             IMultithread::getService("multithread", mode == PASSTHROUGH /* getStub */);
         ASSERT_NE(multithreadInterface, nullptr);
         ASSERT_EQ(multithreadInterface->isRemote(), mode == BINDERIZED);
+
+        trieInterface = ITrie::getService("trie", mode == PASSTHROUGH /* getStub */);
+        ASSERT_NE(trieInterface, nullptr);
+        ASSERT_EQ(trieInterface->isRemote(), mode == BINDERIZED);
     }
 
     virtual void SetUp() {
@@ -456,6 +402,7 @@
     sp<IGraph> graphInterface;
     sp<IPointer> pointerInterface;
     sp<IPointer> validationPointerInterface;
+    sp<ITrie> trieInterface;
     TestMode mode = TestMode::PASSTHROUGH;
 
     virtual void SetUp() override {
@@ -471,24 +418,12 @@
         graphInterface = gHidlEnvironment->graphInterface;
         pointerInterface = gHidlEnvironment->pointerInterface;
         validationPointerInterface = gHidlEnvironment->validationPointerInterface;
+        trieInterface = gHidlEnvironment->trieInterface;
         mode = gHidlEnvironment->mode;
         ALOGI("Test setup complete");
     }
 };
 
-TEST_F(HidlTest, PreloadTest) {
-    // in passthrough mode, this will already be opened
-    if (mode == BINDERIZED) {
-        using android::hardware::preloadPassthroughService;
-
-        static const std::string kLib = "android.hardware.tests.inheritance@1.0-impl.so";
-
-        EXPECT_FALSE(isLibraryOpen(kLib));
-        preloadPassthroughService<IParent>();
-        EXPECT_TRUE(isLibraryOpen(kLib));
-    }
-}
-
 TEST_F(HidlTest, ToStringTest) {
     using namespace android::hardware;
 
@@ -531,6 +466,38 @@
     EXPECT_NE(nullptr, IFoo::getService("\n", true /* getStub */).get());
 }
 
+TEST_F(HidlTest, EnumIteratorTest) {
+    using Empty = ::android::hardware::tests::foo::V1_0::EnumIterators::Empty;
+    using Grandchild = ::android::hardware::tests::foo::V1_0::EnumIterators::Grandchild;
+    using SkipsValues = ::android::hardware::tests::foo::V1_0::EnumIterators::SkipsValues;
+    using MultipleValues = ::android::hardware::tests::foo::V1_0::EnumIterators::MultipleValues;
+
+    for (const auto value : hidl_enum_iterator<Empty>()) {
+        (void)value;
+        EXPECT_TRUE(false) << "Empty iterator should not iterate";
+    }
+
+    auto it1 = hidl_enum_iterator<Grandchild>().begin();
+    EXPECT_EQ(Grandchild::A, *it1++);
+    EXPECT_EQ(Grandchild::B, *it1++);
+    EXPECT_EQ(hidl_enum_iterator<Grandchild>().end(), it1);
+
+    auto it2 = hidl_enum_iterator<SkipsValues>().begin();
+    EXPECT_EQ(SkipsValues::A, *it2++);
+    EXPECT_EQ(SkipsValues::B, *it2++);
+    EXPECT_EQ(SkipsValues::C, *it2++);
+    EXPECT_EQ(SkipsValues::D, *it2++);
+    EXPECT_EQ(SkipsValues::E, *it2++);
+    EXPECT_EQ(hidl_enum_iterator<SkipsValues>().end(), it2);
+
+    auto it3 = hidl_enum_iterator<MultipleValues>().begin();
+    EXPECT_EQ(MultipleValues::A, *it3++);
+    EXPECT_EQ(MultipleValues::B, *it3++);
+    EXPECT_EQ(MultipleValues::C, *it3++);
+    EXPECT_EQ(MultipleValues::D, *it3++);
+    EXPECT_EQ(hidl_enum_iterator<MultipleValues>().end(), it3);
+}
+
 TEST_F(HidlTest, EnumToStringTest) {
     using namespace std::string_literals;
     using ::android::hardware::tests::foo::V1_0::toString;
@@ -541,10 +508,20 @@
     EXPECT_EQ(toString(static_cast<IFoo::BitField>(IFoo::BitField::V0 | IFoo::BitField::V2)), "0x5"s)
             << "Invalid enum isn't stringified correctly.";
     // dump bitfields
-    EXPECT_EQ(toString<IFoo::BitField>(0 | IFoo::BitField::V0), "V0 (0x1)"s);
-    EXPECT_EQ(toString<IFoo::BitField>(0 | IFoo::BitField::V0 | IFoo::BitField::V2), "V0 | V2 (0x5)"s);
-    EXPECT_EQ(toString<IFoo::BitField>(0xF), "V0 | V1 | V2 | V3 | VALL (0xf)"s);
-    EXPECT_EQ(toString<IFoo::BitField>(0xFF), "V0 | V1 | V2 | V3 | VALL | 0xf0 (0xff)"s);
+    EXPECT_EQ(toString<IFoo::BitField>((uint8_t)0 | IFoo::BitField::V0), "V0 (0x1)"s);
+    EXPECT_EQ(toString<IFoo::BitField>((uint8_t)0 | IFoo::BitField::V0 | IFoo::BitField::V2),
+              "V0 | V2 (0x5)"s);
+    EXPECT_EQ(toString<IFoo::BitField>((uint8_t)0xF), "V0 | V1 | V2 | V3 | VALL (0xf)"s);
+    EXPECT_EQ(toString<IFoo::BitField>((uint8_t)0xFF), "V0 | V1 | V2 | V3 | VALL | 0xf0 (0xff)"s);
+
+    // inheritance
+    using Parent = ::android::hardware::tests::foo::V1_0::EnumIterators::Parent;
+    using EmptyChild = ::android::hardware::tests::foo::V1_0::EnumIterators::EmptyChild;
+    using Grandchild = ::android::hardware::tests::foo::V1_0::EnumIterators::Grandchild;
+    EXPECT_EQ(toString(Parent::A), "A"s);
+    EXPECT_EQ(toString(EmptyChild::A), "A"s);
+    EXPECT_EQ(toString(Grandchild::A), "A"s);
+    EXPECT_EQ(toString(Grandchild::B), "B"s);
 }
 
 TEST_F(HidlTest, PingTest) {
@@ -560,17 +537,24 @@
 }
 
 TEST_F(HidlTest, HashTest) {
-    uint8_t ihash[32] = {74,38,204,105,102,117,11,15,207,7,238,198,29,35,30,62,100,
-            216,131,182,3,61,162,241,215,211,6,20,251,143,125,161};
+    static constexpr uint64_t kHashSize = 32u;
+    // unreleased interface has an empty hash
+    uint8_t ihash[kHashSize] = {0};
+    uint8_t ibase[kHashSize] = {189, 218, 182, 24,  77,  122, 52,  109, 166, 160, 125,
+                                192, 130, 140, 241, 154, 105, 111, 76,  170, 54,  17,
+                                197, 31,  46,  20,  86,  90,  20,  180, 15,  217};
     auto service = IHash::getService(mode == PASSTHROUGH /* getStub */);
-    EXPECT_OK(service->getHashChain([&] (const auto &chain) {
-        EXPECT_EQ(chain[0].size(), 32u);
-        EXPECT_ARRAYEQ(ihash, chain[0], 32);
-        EXPECT_OK(manager->getHashChain([&] (const auto &managerChain) {
-            EXPECT_EQ(chain[chain.size() - 1].size(), managerChain[managerChain.size() - 1].size());
-            EXPECT_ARRAYEQ(chain[chain.size() - 1], managerChain[managerChain.size() - 1],
-                    chain[chain.size() - 1].size()) << "Hash for IBase doesn't match!";
-        }));
+    EXPECT_OK(service->getHashChain([&](const auto& chain) {
+        ASSERT_EQ(chain.size(), 2u);
+        EXPECT_EQ(chain[0].size(), kHashSize);
+        EXPECT_ARRAYEQ(ihash, chain[0], kHashSize);
+        EXPECT_EQ(chain[1].size(), kHashSize);
+        EXPECT_ARRAYEQ(ibase, chain[1], kHashSize);
+    }));
+    EXPECT_OK(manager->getHashChain([&](const auto& managerChain) {
+        EXPECT_EQ(managerChain[managerChain.size() - 1].size(), kHashSize);
+        EXPECT_ARRAYEQ(ibase, managerChain[managerChain.size() - 1], kHashSize)
+            << "Hash for IBase doesn't match!";
     }));
 }
 
@@ -624,137 +608,165 @@
     }));
 }
 
-// passthrough TODO(b/31959402)
 TEST_F(HidlTest, ServiceListByInterfaceTest) {
-    if (mode == BINDERIZED) {
-        EXPECT_OK(manager->listByInterface(IParent::descriptor,
-            [](const hidl_vec<hidl_string> &registered) {
-                std::set<std::string> registeredSet;
-
-                for (size_t i = 0; i < registered.size(); i++) {
-                    registeredSet.insert(registered[i]);
-                }
-
-                std::set<std::string> activeSet = {
-                    "parent", "child"
-                };
-                std::set<std::string> difference;
-                std::set_difference(activeSet.begin(), activeSet.end(),
-                                    registeredSet.begin(), registeredSet.end(),
-                                    std::inserter(difference, difference.begin()));
-
-                EXPECT_EQ(difference.size(), 0u) << "service(s) not registered " << to_string(difference);
-            }));
+    if (mode != BINDERIZED) {
+        // passthrough service manager does not know about services
+        return;
     }
+
+    EXPECT_OK(
+        manager->listByInterface(IParent::descriptor, [](const hidl_vec<hidl_string>& registered) {
+            std::set<std::string> registeredSet;
+
+            for (size_t i = 0; i < registered.size(); i++) {
+                registeredSet.insert(registered[i]);
+            }
+
+            std::set<std::string> activeSet = {"parent", "child"};
+            std::set<std::string> difference;
+            std::set_difference(activeSet.begin(), activeSet.end(), registeredSet.begin(),
+                                registeredSet.end(), std::inserter(difference, difference.begin()));
+
+            EXPECT_EQ(difference.size(), 0u)
+                << "service(s) not registered " << to_string(difference);
+        }));
 }
 
-// passthrough TODO(b/31959402)
-TEST_F(HidlTest, ServiceParentTest) {
-    if (mode == BINDERIZED) {
-        sp<IParent> parent = IParent::getService("child");
+TEST_F(HidlTest, SubInterfaceServiceRegistrationTest) {
+    using ::android::hardware::interfacesEqual;
 
-        EXPECT_NE(parent, nullptr);
-    }
+    const std::string kInstanceName = "no-matter-what-it-is";
+    const std::string kOtherName = "something-different";
+
+    sp<IChild> child = new SimpleChild();
+    sp<IParent> parent = new SimpleParent();
+
+    EXPECT_EQ(::android::OK, child->registerAsService(kInstanceName));
+    EXPECT_EQ(::android::OK, child->registerAsService(kOtherName));
+
+    EXPECT_TRUE(interfacesEqual(child, IChild::getService(kInstanceName)));
+    EXPECT_TRUE(interfacesEqual(child, IParent::getService(kInstanceName)));
+
+    EXPECT_EQ(::android::OK, parent->registerAsService(kInstanceName));
+
+    // FALSE since passthrough HAL will return an instance
+    // since binderized instance is nullptr
+    EXPECT_FALSE(interfacesEqual(parent, IChild::getService(kInstanceName)));
+    EXPECT_TRUE(interfacesEqual(parent, IParent::getService(kInstanceName)));
+
+    // other instance name is unchanged
+    EXPECT_TRUE(interfacesEqual(child, IChild::getService(kOtherName)));
+    EXPECT_TRUE(interfacesEqual(child, IParent::getService(kOtherName)));
 }
 
-// passthrough TODO(b/31959402)
 TEST_F(HidlTest, ServiceNotificationTest) {
-    if (mode == BINDERIZED) {
-        ServiceNotification *notification = new ServiceNotification();
-
-        std::string instanceName = "test-instance";
-        EXPECT_TRUE(IParent::registerForNotifications(instanceName, notification));
-
-        EXPECT_EQ(::android::OK, (new SimpleChild())->registerAsService(instanceName));
-        EXPECT_EQ(::android::OK, (new SimpleParent())->registerAsService(instanceName));
-
-        std::unique_lock<std::mutex> lock(notification->mutex);
-
-        notification->condition.wait_for(
-                lock,
-                std::chrono::milliseconds(2),
-                [&notification]() {
-                   return notification->getRegistrations().size() >= 2;
-                });
-
-        std::vector<std::string> registrations = notification->getRegistrations();
-
-        EXPECT_EQ(registrations.size(), 2u);
-
-        EXPECT_EQ(to_string(registrations.data(), registrations.size()),
-                  std::string("['") + IParent::descriptor + "/" + instanceName +
-                             "', '" + IParent::descriptor + "/" + instanceName + "']");
+    if (mode != BINDERIZED) {
+        // service notifications aren't supported in passthrough mode
+        return;
     }
+
+    ServiceNotification* notification = new ServiceNotification();
+
+    std::string instanceName = "test-instance";
+    EXPECT_TRUE(IParent::registerForNotifications(instanceName, notification));
+
+    EXPECT_EQ(::android::OK, (new SimpleChild())->registerAsService(instanceName));
+    EXPECT_EQ(::android::OK, (new SimpleParent())->registerAsService(instanceName));
+
+    std::unique_lock<std::mutex> lock(notification->mutex);
+
+    notification->condition.wait_for(lock, std::chrono::milliseconds(2), [&notification]() {
+        return notification->getRegistrations().size() >= 2;
+    });
+
+    std::vector<std::string> registrations = notification->getRegistrations();
+
+    EXPECT_EQ(registrations.size(), 2u);
+
+    EXPECT_EQ(to_string(registrations.data(), registrations.size()),
+              std::string("['") + IParent::descriptor + "/" + instanceName + "', '" +
+                  IParent::descriptor + "/" + instanceName + "']");
 }
 
 TEST_F(HidlTest, ServiceUnregisterTest) {
-    if (mode == BINDERIZED) {
-        const std::string instance = "some-instance-name";
+    const std::string instance = "some-instance-name";
 
-        sp<ServiceNotification> sNotification = new ServiceNotification();
+    sp<ServiceNotification> sNotification = new ServiceNotification();
 
-        // unregister all
-        EXPECT_TRUE(IParent::registerForNotifications(instance, sNotification));
-        EXPECT_TRUE(manager->unregisterForNotifications("", "", sNotification));
+    // unregister all
+    EXPECT_TRUE(IParent::registerForNotifications(instance, sNotification));
+    EXPECT_TRUE(manager->unregisterForNotifications("", "", sNotification));
 
-        // unregister all with instance name
-        EXPECT_TRUE(IParent::registerForNotifications(instance, sNotification));
-        EXPECT_TRUE(manager->unregisterForNotifications(IParent::descriptor,
-            "", sNotification));
+    // unregister all with instance name
+    EXPECT_TRUE(IParent::registerForNotifications(instance, sNotification));
+    EXPECT_TRUE(manager->unregisterForNotifications(IParent::descriptor, "", sNotification));
 
-        // unregister package listener
-        EXPECT_TRUE(IParent::registerForNotifications("", sNotification));
-        EXPECT_TRUE(manager->unregisterForNotifications(IParent::descriptor,
-            "", sNotification));
+    // unregister package listener
+    EXPECT_TRUE(IParent::registerForNotifications("", sNotification));
+    EXPECT_TRUE(manager->unregisterForNotifications(IParent::descriptor, "", sNotification));
 
-        // unregister listener for specific service and name
-        EXPECT_TRUE(IParent::registerForNotifications(instance, sNotification));
-        EXPECT_TRUE(manager->unregisterForNotifications(IParent::descriptor,
-            instance, sNotification));
+    // unregister listener for specific service and name
+    EXPECT_TRUE(IParent::registerForNotifications(instance, sNotification));
+    EXPECT_TRUE(manager->unregisterForNotifications(IParent::descriptor, instance, sNotification));
 
-        EXPECT_FALSE(manager->unregisterForNotifications("", "", sNotification));
+    EXPECT_FALSE(manager->unregisterForNotifications("", "", sNotification));
 
-        // TODO(b/32837397): remote destructor is lazy
-        // wp<ServiceNotification> wNotification = sNotification;
-        // sNotification = nullptr;
-        // EXPECT_EQ(nullptr, wNotification.promote().get());
-    }
+    // TODO(b/32837397): remote destructor is lazy
+    // wp<ServiceNotification> wNotification = sNotification;
+    // sNotification = nullptr;
+    // EXPECT_EQ(nullptr, wNotification.promote().get());
 }
 
-// passthrough TODO(b/31959402)
 TEST_F(HidlTest, ServiceAllNotificationTest) {
+    ServiceNotification* notification = new ServiceNotification();
+
+    std::string instanceOne = "test-instance-one";
+    std::string instanceTwo = "test-instance-two";
+    EXPECT_TRUE(ISimple::registerForNotifications("", notification));
+
+    Simple* instanceA = new Simple(1);
+    EXPECT_EQ(::android::OK, instanceA->registerAsService(instanceOne));
+    Simple* instanceB = new Simple(2);
+    EXPECT_EQ(::android::OK, instanceB->registerAsService(instanceTwo));
+
+    std::unique_lock<std::mutex> lock(notification->mutex);
+
+    notification->condition.wait_for(lock, std::chrono::milliseconds(2), [&notification]() {
+        return notification->getRegistrations().size() >= 2;
+    });
+
+    std::vector<std::string> registrations = notification->getRegistrations();
+    std::sort(registrations.begin(), registrations.end());
+
+    EXPECT_EQ(registrations.size(), 2u);
+
+    std::string descriptor = ISimple::descriptor;
+
+    EXPECT_EQ(
+        to_string(registrations.data(), registrations.size()),
+        "['" + descriptor + "/" + instanceOne + "', '" + descriptor + "/" + instanceTwo + "']");
+}
+
+TEST_F(HidlTest, InterfacesEqualTest) {
+    using android::hardware::interfacesEqual;
+
+    sp<IParent> service1 = IParent::getService("child", mode == PASSTHROUGH /* getStub */);
+    sp<IParent> service2 = service1;
+
+    // Passthrough services are reinstantiated whenever getService is called.
     if (mode == BINDERIZED) {
-        ServiceNotification *notification = new ServiceNotification();
-
-        std::string instanceOne = "test-instance-one";
-        std::string instanceTwo = "test-instance-two";
-        EXPECT_TRUE(ISimple::registerForNotifications("", notification));
-
-        Simple* instanceA = new Simple(1);
-        EXPECT_EQ(::android::OK, instanceA->registerAsService(instanceOne));
-        Simple* instanceB = new Simple(2);
-        EXPECT_EQ(::android::OK, instanceB->registerAsService(instanceTwo));
-
-        std::unique_lock<std::mutex> lock(notification->mutex);
-
-        notification->condition.wait_for(
-                lock,
-                std::chrono::milliseconds(2),
-                [&notification]() {
-                   return notification->getRegistrations().size() >= 2;
-                });
-
-        std::vector<std::string> registrations = notification->getRegistrations();
-        std::sort(registrations.begin(), registrations.end());
-
-        EXPECT_EQ(registrations.size(), 2u);
-
-        std::string descriptor = ISimple::descriptor;
-
-        EXPECT_EQ(to_string(registrations.data(), registrations.size()),
-                  "['" + descriptor + "/" + instanceOne + "', '"
-                       + descriptor + "/" + instanceTwo + "']");
+        service2 = IParent::getService("child");
     }
+
+    EXPECT_NE(nullptr, service1.get());
+    EXPECT_NE(nullptr, service2.get());
+    EXPECT_TRUE(interfacesEqual(service1, service2));
+
+    sp<IChild> child = IChild::castFrom(service1);
+    EXPECT_NE(nullptr, child.get());  // it is actually a child
+
+    EXPECT_TRUE(interfacesEqual(service1, child));
+    EXPECT_TRUE(interfacesEqual(service2, child));
 }
 
 TEST_F(HidlTest, TestToken) {
@@ -889,19 +901,57 @@
     }
 }
 
-inline uint64_t operator""_GB(unsigned long long num) {
-    return num * 1024 * 1024 * 1024;
-}
+TEST_F(HidlTest, MemoryBlock) {
+    const uint8_t kValue = 0xCA;
+    using ::android::hardware::IBinder;
+    using ::android::hardware::interfacesEqual;
+    using ::android::hardware::toBinder;
 
-TEST_F(HidlTest, FailedBatchSharedMemory) {
-    EXPECT_OK(ashmemAllocator->batchAllocate(1024, UINT64_MAX, [&](bool success, const auto& v) {
-        EXPECT_FALSE(success);
-        EXPECT_EQ(0u, v.size());
+    sp<HidlMemory> mem;
+    EXPECT_OK(ashmemAllocator->allocate(1024, [&](bool success, const hidl_memory& _mem) {
+        ASSERT_TRUE(success);
+        mem = HidlMemory::getInstance(_mem);
     }));
-    EXPECT_OK(ashmemAllocator->batchAllocate(1_GB, 1024, [&](bool success, const auto& v) {
-        EXPECT_FALSE(success);
-        EXPECT_EQ(0u, v.size());
+    memoryTest->set(*mem);
+    Return<sp<IMemoryToken>> tokenRet = memoryTest->get();
+    EXPECT_OK(tokenRet);
+    sp<IMemoryToken> token = tokenRet;
+    EXPECT_NE(nullptr, token.get());
+    EXPECT_OK(token->get([&](const hidl_memory& mem) {
+        sp<IMemory> memory = mapMemory(mem);
+
+        EXPECT_NE(nullptr, memory.get());
+
+        uint8_t* data = static_cast<uint8_t*>(static_cast<void*>(memory->getPointer()));
+        EXPECT_NE(data, nullptr);
+
+        EXPECT_EQ(memory->getSize(), mem.size());
+
+        memory->update();
+        memset(data, 0, memory->getSize());
+        memory->commit();
+
+        memoryTest->fillMemory(mem, kValue);
+        memory->commit();
     }));
+    MemoryBlock blk = {token, 0x200 /* size */, 0x100 /* offset */};
+    EXPECT_OK(memoryTest->haveSomeMemoryBlock(blk, [&](const MemoryBlock& blkBack) {
+        sp<IMemoryToken> tokenBack = blkBack.token;
+        EXPECT_TRUE(interfacesEqual(token, tokenBack));
+        EXPECT_EQ(blkBack.size, 0x200ULL);
+        EXPECT_EQ(blkBack.offset, 0x100ULL);
+        blk = blkBack;
+    }));
+
+    sp<IMemoryToken> mtoken = blk.token;
+    mtoken->get([&](const hidl_memory& mem) {
+        sp<IMemory> memory = mapMemory(mem);
+        uint8_t* data = static_cast<uint8_t*>(static_cast<void*>(memory->getPointer()));
+        EXPECT_NE(data, nullptr);
+        for (size_t i = 0; i < mem.size(); i++) {
+            EXPECT_EQ(kValue, data[i]);
+        }
+    });
 }
 
 TEST_F(HidlTest, NullSharedMemory) {
@@ -922,6 +972,23 @@
     }));
 }
 
+TEST_F(HidlTest, FooConvertToBoolIfSmallTest) {
+    hidl_vec<IFoo::Union> u = {
+        {.intValue = 7}, {.intValue = 0}, {.intValue = 1}, {.intValue = 8},
+    };
+    EXPECT_OK(foo->convertToBoolIfSmall(IFoo::Discriminator::INT, u, [&](const auto& res) {
+        ASSERT_EQ(4u, res.size());
+        EXPECT_EQ(IFoo::Discriminator::INT, res[0].discriminator);
+        EXPECT_EQ(u[0].intValue, res[0].value.intValue);
+        EXPECT_EQ(IFoo::Discriminator::BOOL, res[1].discriminator);
+        EXPECT_EQ(static_cast<bool>(u[1].intValue), res[1].value.boolValue);
+        EXPECT_EQ(IFoo::Discriminator::BOOL, res[2].discriminator);
+        EXPECT_EQ(static_cast<bool>(u[2].intValue), res[2].value.boolValue);
+        EXPECT_EQ(IFoo::Discriminator::INT, res[3].discriminator);
+        EXPECT_EQ(u[3].intValue, res[3].value.intValue);
+    }));
+}
+
 TEST_F(HidlTest, FooDoThisTest) {
     ALOGI("CLIENT call doThis.");
     EXPECT_OK(foo->doThis(1.0f));
@@ -1669,6 +1736,72 @@
     EXPECT_OK(bar->thisIsNew());
 }
 
+TEST_F(HidlTest, TrieSimpleTest) {
+    trieInterface->newTrie([&](const TrieNode& trie) {
+        trieInterface->addStrings(trie, {"a", "ba"}, [&](const TrieNode& trie) {
+            trieInterface->containsStrings(
+                trie, {"", "a", "b", "ab", "ba", "c"}, [](const hidl_vec<bool>& response) {
+                    EXPECT_EQ(response,
+                              std::vector<bool>({false, true, false, false, true, false}));
+                });
+
+            trieInterface->addStrings(trie, {"", "ab", "bab"}, [&](const TrieNode& trie) {
+                trieInterface->containsStrings(
+                    trie, {"", "a", "b", "ab", "ba", "c"}, [](const hidl_vec<bool>& response) {
+                        EXPECT_EQ(response,
+                                  std::vector<bool>({true, true, false, true, true, false}));
+                    });
+            });
+        });
+    });
+}
+
+struct RandomString {
+    std::string next() {
+        std::string ret(lengthDist(rng), 0);
+        std::generate(ret.begin(), ret.end(), [&]() { return charDist(rng); });
+        return ret;
+    }
+
+    RandomString() : rng(std::random_device{}()), lengthDist(5, 10), charDist('a', 'a' + 10) {}
+
+   private:
+    std::default_random_engine rng;
+    std::uniform_int_distribution<> lengthDist;
+    std::uniform_int_distribution<> charDist;
+};
+
+TEST_F(HidlTest, TrieStressTest) {
+    const size_t REQUEST_NUM = 1000;
+    RandomString stringGenerator;
+
+    trieInterface->newTrie([&](const TrieNode& trie) {
+        std::vector<std::string> strings(REQUEST_NUM);
+        for (auto& str : strings) {
+            str = stringGenerator.next();
+        }
+
+        trieInterface->addStrings(
+            trie, hidl_vec<hidl_string>(strings.begin(), strings.end()), [&](const TrieNode& trie) {
+                std::unordered_set<std::string> addedStrings(strings.begin(), strings.end());
+
+                for (size_t i = 0; i != REQUEST_NUM; ++i) {
+                    strings.push_back(stringGenerator.next());
+                }
+
+                std::vector<bool> trueResponse(strings.size());
+                std::transform(strings.begin(), strings.end(), trueResponse.begin(),
+                               [&](const std::string& str) {
+                                   return addedStrings.find(str) != addedStrings.end();
+                               });
+
+                trieInterface->containsStrings(
+                    trie, hidl_vec<hidl_string>(strings.begin(), strings.end()),
+                    [&](const hidl_vec<bool>& response) { EXPECT_EQ(response, trueResponse); });
+            });
+    });
+}
+
 class HidlMultithreadTest : public ::testing::Test {
    public:
     sp<IMultithread> multithreadInterface;
@@ -2010,9 +2143,11 @@
 #endif
 
 template <class T>
-static void waitForServer(const std::string &serviceName) {
-    ::android::hardware::details::waitForHwService(T::descriptor, serviceName);
-}
+struct WaitForServer {
+    static void run(const std::string& serviceName) {
+        ::android::hardware::details::waitForHwService(T::descriptor, serviceName);
+    }
+};
 
 int forkAndRunTests(TestMode mode, bool enableDelayMeasurementTests) {
     pid_t child;
@@ -2122,7 +2257,7 @@
         handleStatus(pStatus, "PASSTHROUGH");
     }
     if (b) {
-        EACH_SERVER(waitForServer);
+        runOnEachServer<WaitForServer>();
         ALOGI("BINDERIZED Test result = %d", bStatus);
         handleStatus(bStatus, "BINDERIZED ");
     }
diff --git a/test/hidl_test_helper b/test/hidl_test/hidl_test_helper
similarity index 100%
rename from test/hidl_test_helper
rename to test/hidl_test/hidl_test_helper
diff --git a/test/hidl_test/hidl_test_servers.cpp b/test/hidl_test/hidl_test_servers.cpp
new file mode 100644
index 0000000..2862002
--- /dev/null
+++ b/test/hidl_test/hidl_test_servers.cpp
@@ -0,0 +1,103 @@
+/*
+ * Copyright (C) 2017 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.
+ */
+
+#define LOG_TAG "hidl_test_servers"
+
+#include "hidl_test.h"
+
+#include <android-base/logging.h>
+
+#include <android/hardware/tests/baz/1.0/IBaz.h>
+
+#include <hidl/LegacySupport.h>
+
+#include <hwbinder/IPCThreadState.h>
+
+#include <sys/wait.h>
+#include <signal.h>
+
+#include <string>
+#include <utility>
+#include <vector>
+
+using ::android::hardware::tests::baz::V1_0::IBaz;
+
+using ::android::hardware::defaultPassthroughServiceImplementation;
+using ::android::hardware::IPCThreadState;
+
+static std::vector<std::pair<std::string, pid_t>> gPidList;
+
+void signal_handler_server(int signal) {
+    if (signal == SIGTERM) {
+        IPCThreadState::shutdown();
+        exit(0);
+    }
+}
+
+template <class T>
+struct ForkServer {
+    static void run(const std::string& serviceName) {
+        pid_t pid;
+
+        if ((pid = fork()) == 0) {
+            // in child process
+            signal(SIGTERM, signal_handler_server);
+            int status = defaultPassthroughServiceImplementation<T>(serviceName);
+            exit(status);
+        }
+
+        gPidList.push_back({serviceName, pid});
+    }
+};
+
+static void killServer(pid_t pid, const char *serverName) {
+    if (kill(pid, SIGTERM)) {
+        ALOGE("Could not kill %s; errno = %d", serverName, errno);
+    } else {
+        int status;
+        ALOGE("Waiting for %s to exit...", serverName);
+        waitpid(pid, &status, 0);
+        if (status != 0) {
+            ALOGE("%s terminates abnormally with status %d", serverName, status);
+        } else {
+            ALOGE("%s killed successfully", serverName);
+        }
+        ALOGE("Continuing...");
+    }
+}
+
+void signal_handler(int signal) {
+    if (signal == SIGTERM) {
+        for (auto p : gPidList) {
+            killServer(p.second, p.first.c_str());
+        }
+        exit(0);
+    }
+}
+
+int main(int /* argc */, char* /* argv */ []) {
+    setenv("TREBLE_TESTING_OVERRIDE", "true", true);
+
+    runOnEachServer<ForkServer>();
+
+    ForkServer<IBaz>::run("dyingBaz");
+
+    signal(SIGTERM, signal_handler);
+    // Parent process should not exit before the forked child processes.
+    pause();
+
+    return 0;
+}
diff --git a/test/hidl_test/static_test.cpp b/test/hidl_test/static_test.cpp
new file mode 100644
index 0000000..3222f03
--- /dev/null
+++ b/test/hidl_test/static_test.cpp
@@ -0,0 +1,265 @@
+
+#include <android/hardware/tests/bar/1.0/IImportRules.h>
+#include <android/hardware/tests/expression/1.0/IExpression.h>
+#include <android/hardware/tests/foo/1.0/IFoo.h>
+
+using ::android::hardware::Return;
+using ::android::hardware::Void;
+using ::android::hardware::hidl_array;
+using ::android::hardware::tests::bar::V1_0::IImportRules;
+using ::android::hardware::tests::expression::V1_0::IExpression;
+using ::android::hardware::tests::foo::V1_0::IFoo;
+using ::android::sp;
+
+namespace {
+
+// Check array dimension order
+static_assert(std::is_same<IFoo::multidimArrayOne, hidl_array<int32_t, 5, 6, 7>>::value,
+              "hidl-gen output array dimention order is incorrect");
+static_assert(std::is_same<IFoo::multidimArrayTwo, hidl_array<int32_t, 8, 9, 10, 5, 6, 7>>::value,
+              "hidl-gen output array dimention order is incorrect");
+static_assert(
+    std::is_same<IFoo::multidimArrayThree, hidl_array<int32_t, 2, 3, 4, 8, 9, 10, 5, 6, 7>>::value,
+    "hidl-gen output array dimention order is incorrect");
+
+// Check correct type in ambiguous case
+static_assert(std::is_same<decltype(IFoo::S1::foo), IFoo::InnerTestStruct>::value,
+              "hidl-gen wrong (inner) type in output");
+static_assert(!std::is_same<decltype(IFoo::S1::foo), IFoo::S1::InnerTestStruct>::value,
+              "hidl-gen wrong (inner) type in output");
+static_assert((int32_t) decltype(IFoo::S2::foo)::VALUE == 0,
+              "hidl-gen wrong (inner) type in output");
+
+// Ensure (statically) that the types in IImportRules resolves to the correct types by
+// overriding the methods with fully namespaced types as arguments.
+struct MyImportRules : public IImportRules {
+    Return<void> rule0a(
+        const ::android::hardware::tests::bar::V1_0::IImportRules::Outer&) override {
+        return Void();
+    }
+
+    Return<void> rule0a1(
+        const ::android::hardware::tests::bar::V1_0::IImportRules::Outer&) override {
+        return Void();
+    }
+
+    Return<void> rule0b(
+        const ::android::hardware::tests::bar::V1_0::IImportRules::Outer&) override {
+        return Void();
+    }
+
+    Return<void> rule0b1(
+        const ::android::hardware::tests::bar::V1_0::IImportRules::Outer&) override {
+        return Void();
+    }
+
+    Return<void> rule0c(const ::android::hardware::tests::foo::V1_0::Outer&) override {
+        return Void();
+    }
+
+    Return<void> rule0d(const ::android::hardware::tests::foo::V1_0::Outer&) override {
+        return Void();
+    }
+
+    Return<void> rule0e(
+        const ::android::hardware::tests::bar::V1_0::IImportRules::Outer::Inner&) override {
+        return Void();
+    }
+
+    Return<void> rule0f(
+        const ::android::hardware::tests::bar::V1_0::IImportRules::Outer::Inner&) override {
+        return Void();
+    }
+
+    Return<void> rule0g(const ::android::hardware::tests::foo::V1_0::Outer::Inner&) override {
+        return Void();
+    }
+
+    Return<void> rule0h(const ::android::hardware::tests::foo::V1_0::Outer::Inner&) override {
+        return Void();
+    }
+
+    Return<void> rule1a(const ::android::hardware::tests::bar::V1_0::Def&) override {
+        return Void();
+    }
+
+    Return<void> rule1b(const ::android::hardware::tests::foo::V1_0::Def&) override {
+        return Void();
+    }
+
+    Return<void> rule2a(const ::android::hardware::tests::foo::V1_0::Unrelated&) override {
+        return Void();
+    }
+
+    Return<void> rule2b(const sp<::android::hardware::tests::foo::V1_0::IFooCallback>&) override {
+        return Void();
+    }
+};
+
+template <typename E>
+constexpr bool operator==(E actual, typename std::underlying_type<E>::type expected) {
+    return expected == static_cast<typename std::underlying_type<E>::type>(actual);
+}
+
+// See IExpression.hal
+// Use the C++ compiler to compute these expressions and make sure hidl-gen emits the same result.
+static_assert(IExpression::UInt64LiteralTypeGuessing::noSuffixDec1 == 0, "");
+static_assert(IExpression::UInt64LiteralTypeGuessing::noSuffixDec2 == 1, "");
+static_assert(IExpression::UInt64LiteralTypeGuessing::noSuffixDec3 == -1, "");
+static_assert(IExpression::UInt64LiteralTypeGuessing::noSuffixDec4 == ~0, "");
+static_assert(IExpression::UInt64LiteralTypeGuessing::noSuffixDec5 == 2147483647, "");
+static_assert(IExpression::UInt64LiteralTypeGuessing::noSuffixDec6 == -2147483648, "");
+static_assert(IExpression::UInt64LiteralTypeGuessing::noSuffixDec7 == 2147483648, "");
+static_assert(IExpression::UInt64LiteralTypeGuessing::noSuffixDec8 == -2147483649, "");
+static_assert(IExpression::UInt64LiteralTypeGuessing::noSuffixDec9 == ~(-1), "");
+static_assert(IExpression::UInt64LiteralTypeGuessing::noSuffixHex1 == 0x7fffffff, "");
+static_assert(IExpression::UInt64LiteralTypeGuessing::noSuffixHex2 == 0x80000000, "");
+static_assert(IExpression::UInt64LiteralTypeGuessing::noSuffixHex3 == 0xffffffff, "");
+static_assert(IExpression::UInt64LiteralTypeGuessing::longHex1 == 0xffffffffl, "");
+static_assert(IExpression::UInt64LiteralTypeGuessing::longHex2 == 0Xfffffffff, "");
+static_assert(IExpression::UInt64LiteralTypeGuessing::longHex3 == 0x7fffffffffffffff, "");
+static_assert(IExpression::UInt64LiteralTypeGuessing::longHex4 == 0x8000000000000000, "");
+static_assert(IExpression::UInt64LiteralTypeGuessing::longHex5 == 0xFFFFFFFFFFFFFFFF, "");
+
+static_assert(IExpression::SuffixedLiteralTypeGuessing::decInt32_1 == 1, "");
+static_assert(IExpression::SuffixedLiteralTypeGuessing::decInt32_2 == 1, "");
+static_assert(IExpression::SuffixedLiteralTypeGuessing::decInt64_1 == 1, "");
+static_assert(IExpression::SuffixedLiteralTypeGuessing::decInt64_2 == 1, "");
+static_assert(IExpression::SuffixedLiteralTypeGuessing::decInt64_3 == 1, "");
+static_assert(IExpression::SuffixedLiteralTypeGuessing::decInt64_4 == 1, "");
+static_assert(IExpression::SuffixedLiteralTypeGuessing::hexInt32_1 == 1, "");
+static_assert(IExpression::SuffixedLiteralTypeGuessing::hexUInt32_1 == 1, "");
+static_assert(IExpression::SuffixedLiteralTypeGuessing::hexUInt32_2 == 1, "");
+static_assert(IExpression::SuffixedLiteralTypeGuessing::hexInt64_1 == 1, "");
+static_assert(IExpression::SuffixedLiteralTypeGuessing::hexUInt64_1 == 1, "");
+
+static_assert(IExpression::Int64LiteralTypeGuessing::noSuffixDec11 == -2147483648,
+              "1 + 0x7fffffff");
+static_assert(IExpression::Int64LiteralTypeGuessing::noSuffixDec12 == 2147483647, "0x80000000 - 1");
+
+static_assert(IExpression::Int32BitShifting::int32BitShift1 == 1 << 31, "");
+static_assert(IExpression::UInt32BitShifting::uint32BitShift1 == 1 << 31, "");
+static_assert(IExpression::Int64BitShifting::int64BitShift1 == 1LL << 63, "1l << 63");
+static_assert(IExpression::UInt64BitShifting::uint64BitShift1 == 1LL << 63, "1l << 63");
+
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wconstant-logical-operand"
+#pragma clang diagnostic ignored "-Wlogical-op-parentheses"
+#pragma clang diagnostic ignored "-Wbitwise-op-parentheses"
+
+static_assert(IExpression::Precedence::literal == (4), "");
+static_assert(IExpression::Precedence::neg == (-4), "");
+static_assert(IExpression::Precedence::literalL == (-4L), "");
+static_assert(IExpression::Precedence::hex == (0xffffffff), "");
+static_assert(IExpression::Precedence::hexLong == (0xffffffffl), "");
+static_assert(IExpression::Precedence::hexLong2 == (0xfffffffff), "");
+static_assert(IExpression::Precedence::simpleArithmetic == (4 + 1), "");
+static_assert(IExpression::Precedence::simpleArithmetic2 == (2 + 3 - 4), "");
+static_assert(IExpression::Precedence::simpleArithmetic3 == (2 - 3 + 4), "");
+static_assert(IExpression::Precedence::simpleBoolExpr == (1 == 4), "");
+static_assert(IExpression::Precedence::simpleLogical == (1 && 1), "");
+static_assert(IExpression::Precedence::simpleLogical2 == (1 || 1 && 0),
+              "&& higher than || in HIDL");
+static_assert(IExpression::Precedence::simpleComp == (1 < 2), "");
+static_assert(IExpression::Precedence::boolExpr1 == (!((3 != 4 || (2 < 3 <= 3 > 4)) >= 0)), "");
+static_assert(IExpression::Precedence::boolExpr == (1 == 7 && !((3 != 4 || (2 < 3 <= 3 > 4)) >= 0)),
+              "");
+static_assert(IExpression::Precedence::simpleBitShift == (1 << 2), "");
+static_assert(IExpression::Precedence::simpleBitShift2 == (4 >> 1), "");
+// Shifting negative number of bits is UB in HIDL, so the value is not tested.
+// static_assert(IExpression::Precedence::simpleBitShiftNeg == (4 << -1), "");
+static_assert(IExpression::Precedence::simpleArithmeticRightShift == (1 << 31 >> 31), "");
+static_assert(IExpression::Precedence::simpleBitExpr == (1 | 16 >> 2), "");
+static_assert(IExpression::Precedence::simpleBitExpr2 == (0x0f ^ 0x33 & 0x99),
+              "& higher than ^ in HIDL");
+static_assert(IExpression::Precedence::bitExpr == (~42 & (1 << 3 | 16 >> 2) ^ 7),
+              "& higher than ^ in HIDL");
+static_assert(IExpression::Precedence::arithmeticExpr == (2 + 3 - 4 * -7 / (10 % 3)), "");
+static_assert(IExpression::Precedence::messyExpr == (2 + (-3 & 4 / 7)), "");
+static_assert(IExpression::Precedence::paranExpr == ((((((1 + 1)))))), "");
+static_assert(IExpression::Precedence::ternary == (1 ? 2 : 3), "");
+static_assert(IExpression::Precedence::ternary2 == (1 && 2 ? 3 : 4), "");
+static_assert(IExpression::Precedence::complicatedTernary2 == (1 - 1 && 2 + 3 || 5 ? 7 * 8 : -3),
+              "&& higher than || in HIDL");
+
+#pragma clang diagnostic pop
+
+static_assert(IExpression::OperatorSanityCheck::plus == 1, "");
+static_assert(IExpression::OperatorSanityCheck::minus == 1, "");
+static_assert(IExpression::OperatorSanityCheck::product == 1, "");
+static_assert(IExpression::OperatorSanityCheck::division == 1, "");
+static_assert(IExpression::OperatorSanityCheck::mod == 1, "");
+static_assert(IExpression::OperatorSanityCheck::bit_or == 1, "");
+static_assert(IExpression::OperatorSanityCheck::bit_or2 == 1, "");
+static_assert(IExpression::OperatorSanityCheck::bit_and == 1, "");
+static_assert(IExpression::OperatorSanityCheck::bit_xor == 1, "");
+static_assert(IExpression::OperatorSanityCheck::lt1 == 1, "");
+static_assert(IExpression::OperatorSanityCheck::lt2 == 1, "");
+static_assert(IExpression::OperatorSanityCheck::gt1 == 1, "");
+static_assert(IExpression::OperatorSanityCheck::gt2 == 1, "");
+static_assert(IExpression::OperatorSanityCheck::gte1 == 1, "");
+static_assert(IExpression::OperatorSanityCheck::gte2 == 1, "");
+static_assert(IExpression::OperatorSanityCheck::lte1 == 1, "");
+static_assert(IExpression::OperatorSanityCheck::lte2 == 1, "");
+static_assert(IExpression::OperatorSanityCheck::ne1 == 1, "");
+static_assert(IExpression::OperatorSanityCheck::ne2 == 1, "");
+static_assert(IExpression::OperatorSanityCheck::lshift == 1, "");
+static_assert(IExpression::OperatorSanityCheck::rshift == 1, "");
+static_assert(IExpression::OperatorSanityCheck::logor1 == 1, "");
+static_assert(IExpression::OperatorSanityCheck::logor2 == 1, "");
+static_assert(IExpression::OperatorSanityCheck::logor3 == 1, "");
+static_assert(IExpression::OperatorSanityCheck::logor4 == 1, "");
+static_assert(IExpression::OperatorSanityCheck::logand1 == 1, "");
+static_assert(IExpression::OperatorSanityCheck::logand2 == 1, "");
+static_assert(IExpression::OperatorSanityCheck::logand3 == 1, "");
+static_assert(IExpression::OperatorSanityCheck::logand4 == 1, "");
+
+static_assert(IExpression::Grayscale::WHITE == 126, "");
+static_assert(IExpression::Grayscale::GRAY == 127, "");
+static_assert(IExpression::Grayscale::DARK_GRAY == -128, "");
+static_assert(IExpression::Grayscale::BLACK == -127, "");
+
+static_assert(IExpression::Color::RED == -126, "");
+static_assert(IExpression::Color::RUBY == 0, "");
+static_assert(IExpression::Color::GREEN == 1, "");
+static_assert(IExpression::Color::BLUE == 5, "");
+static_assert(IExpression::Color::CYAN == 6, "");
+static_assert(IExpression::Color::ORANGE == 7, "");
+static_assert(IExpression::Color::ROSE == 126, "");
+
+static_assert(std::is_same<std::underlying_type<IExpression::Foo1>::type,
+                           std::underlying_type<IExpression::Foo2>::type>::value,
+              "");
+static_assert(std::is_same<std::underlying_type<IExpression::Foo1>::type,
+                           std::underlying_type<IExpression::Foo3>::type>::value,
+              "");
+static_assert(std::is_same<std::underlying_type<IExpression::Foo1>::type,
+                           std::underlying_type<IExpression::Foo4>::type>::value,
+              "");
+static_assert(IExpression::Foo3::BAR1 == 0, "");
+static_assert(IExpression::Foo3::BAR2 == 10, "");
+static_assert(IExpression::Foo4::BAR3 == 11, "");
+static_assert(IExpression::Foo4::BAR4 == 21, "");
+
+static_assert(IExpression::Number::MAX == 255, "");
+static_assert(IExpression::Number::MAX_PLUS_1 == 0, "");
+static_assert(IExpression::Number::MAX_PLUS_2 == 1, "");
+
+static_assert(IExpression::Constants::CONST_FOO == 0, "");
+static_assert(IExpression::Constants::CONST_BAR == 70, "");
+static_assert(IExpression::Constants::MAX_ARRAY_SIZE == 20, "");
+static_assert(IExpression::Constants::MAX_ARRAY_SIZE2 == 21, "");
+static_assert(IExpression::Constants::MAX_ARRAY_SIZE3 == 40, "");
+static_assert(IExpression::Constants::MY_INT32_MAX_MINUS_1 == 0x7FFFFFFE, "");
+static_assert(IExpression::Constants::MY_INT32_MAX == 0x7FFFFFFF, "");
+static_assert(IExpression::Constants::MY_INT32_MIN == 0x80000000, "");
+static_assert(IExpression::Constants::MY_INT32_MIN_PLUS_1 == 0x80000001, "");
+
+// Ensure (statically) that the array sizes in function arguments are correct.
+struct Expression : public IExpression {
+    Return<void> foo1(const hidl_array<int32_t, 1>&) override { return Void(); }
+    Return<void> foo2(const hidl_array<int32_t, 13>&) override { return Void(); }
+    Return<void> foo3(const hidl_array<int32_t, 20>&) override { return Void(); }
+};
+
+}  // anonymous namespace
diff --git a/test/hidl_test_servers.cpp b/test/hidl_test_servers.cpp
deleted file mode 100644
index cd14d30..0000000
--- a/test/hidl_test_servers.cpp
+++ /dev/null
@@ -1,123 +0,0 @@
-/*
- * Copyright (C) 2017 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.
- */
-
-#define LOG_TAG "hidl_test_servers"
-
-#include "hidl_test.h"
-
-#include <android-base/logging.h>
-
-#include <android/hardware/tests/bar/1.0/IBar.h>
-#include <android/hardware/tests/baz/1.0/IBaz.h>
-#include <android/hardware/tests/foo/1.0/BnHwSimple.h>
-#include <android/hardware/tests/foo/1.0/BpHwSimple.h>
-#include <android/hardware/tests/foo/1.0/BsSimple.h>
-#include <android/hardware/tests/hash/1.0/IHash.h>
-#include <android/hardware/tests/inheritance/1.0/IChild.h>
-#include <android/hardware/tests/inheritance/1.0/IFetcher.h>
-#include <android/hardware/tests/inheritance/1.0/IParent.h>
-#include <android/hardware/tests/memory/1.0/IMemoryTest.h>
-#include <android/hardware/tests/multithread/1.0/IMultithread.h>
-#include <android/hardware/tests/pointer/1.0/IGraph.h>
-#include <android/hardware/tests/pointer/1.0/IPointer.h>
-
-#include <hidl/LegacySupport.h>
-
-#include <hwbinder/IPCThreadState.h>
-
-#include <sys/wait.h>
-#include <signal.h>
-
-#include <string>
-#include <utility>
-#include <vector>
-
-using ::android::hardware::tests::bar::V1_0::IBar;
-using ::android::hardware::tests::baz::V1_0::IBaz;
-using ::android::hardware::tests::hash::V1_0::IHash;
-using ::android::hardware::tests::inheritance::V1_0::IFetcher;
-using ::android::hardware::tests::inheritance::V1_0::IParent;
-using ::android::hardware::tests::inheritance::V1_0::IChild;
-using ::android::hardware::tests::pointer::V1_0::IGraph;
-using ::android::hardware::tests::pointer::V1_0::IPointer;
-using ::android::hardware::tests::memory::V1_0::IMemoryTest;
-using ::android::hardware::tests::multithread::V1_0::IMultithread;
-
-using ::android::hardware::defaultPassthroughServiceImplementation;
-using ::android::hardware::IPCThreadState;
-
-static std::vector<std::pair<std::string, pid_t>> gPidList;
-
-void signal_handler_server(int signal) {
-    if (signal == SIGTERM) {
-        IPCThreadState::shutdown();
-        exit(0);
-    }
-}
-
-template <class T>
-static void forkServer(const std::string &serviceName) {
-    pid_t pid;
-
-    if ((pid = fork()) == 0) {
-        // in child process
-        signal(SIGTERM, signal_handler_server);
-        int status = defaultPassthroughServiceImplementation<T>(serviceName);
-        exit(status);
-    }
-
-    gPidList.push_back({serviceName, pid});
-    return;
-}
-
-static void killServer(pid_t pid, const char *serverName) {
-    if (kill(pid, SIGTERM)) {
-        ALOGE("Could not kill %s; errno = %d", serverName, errno);
-    } else {
-        int status;
-        ALOGE("Waiting for %s to exit...", serverName);
-        waitpid(pid, &status, 0);
-        if (status != 0) {
-            ALOGE("%s terminates abnormally with status %d", serverName, status);
-        } else {
-            ALOGE("%s killed successfully", serverName);
-        }
-        ALOGE("Continuing...");
-    }
-}
-
-void signal_handler(int signal) {
-    if (signal == SIGTERM) {
-        for (auto p : gPidList) {
-            killServer(p.second, p.first.c_str());
-        }
-        exit(0);
-    }
-}
-
-int main(int /* argc */, char* /* argv */ []) {
-    setenv("TREBLE_TESTING_OVERRIDE", "true", true);
-
-    EACH_SERVER(forkServer);
-
-    forkServer<IBaz>("dyingBaz");
-
-    signal(SIGTERM, signal_handler);
-    // Parent process should not exit before the forked child processes.
-    pause();
-
-    return 0;
-}
diff --git a/test/host_test/Android.bp b/test/host_test/Android.bp
new file mode 100644
index 0000000..d5e6511
--- /dev/null
+++ b/test/host_test/Android.bp
@@ -0,0 +1,26 @@
+// Copyright (C) 2017 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.
+
+cc_test_host {
+    name: "hidl-gen-host_test",
+    defaults: ["hidl-gen-defaults"],
+
+    shared_libs: [
+        "libhidl-gen",
+        "libhidl-gen-ast",
+        "libhidl-gen-utils",
+    ],
+
+    srcs: ["main.cpp"],
+}
\ No newline at end of file
diff --git a/test/host_test/main.cpp b/test/host_test/main.cpp
new file mode 100644
index 0000000..9377306
--- /dev/null
+++ b/test/host_test/main.cpp
@@ -0,0 +1,113 @@
+/*
+ * Copyright (C) 2016 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.
+ */
+
+#define LOG_TAG "libhidl-gen-utils"
+
+#include <gtest/gtest.h>
+
+#include <ConstantExpression.h>
+#include <Coordinator.h>
+#include <hidl-util/FQName.h>
+
+#define EXPECT_EQ_OK(expectResult, call, ...)        \
+    do {                                             \
+        std::string result;                          \
+        status_t err = (call)(__VA_ARGS__, &result); \
+        EXPECT_EQ(err, ::android::OK);               \
+        EXPECT_EQ(expectResult, result);             \
+    } while (false)
+
+namespace android {
+
+class HidlGenHostTest : public ::testing::Test {};
+
+TEST_F(HidlGenHostTest, CoordinatorTest) {
+    Coordinator coordinator;
+
+    std::string error;
+    EXPECT_EQ(OK, coordinator.addPackagePath("a.b", "a1/b1", &error));
+    EXPECT_TRUE(error.empty());
+    EXPECT_NE(OK, coordinator.addPackagePath("a.b", "a2/b2/", &error));
+    EXPECT_FALSE(error.empty());
+
+    coordinator.addDefaultPackagePath("a.b", "a3/b3/"); // should take path above
+    coordinator.addDefaultPackagePath("a.c", "a4/b4/"); // should succeed
+
+    EXPECT_EQ_OK("a.b", coordinator.getPackageRoot, FQName("a.b.foo@1.0"));
+    EXPECT_EQ_OK("a.c", coordinator.getPackageRoot, FQName("a.c.foo.bar@1.0::IFoo"));
+
+    // getPackagePath(fqname, relative, sanitized, ...)
+    EXPECT_EQ_OK("a1/b1/foo/1.0/", coordinator.getPackagePath, FQName("a.b.foo@1.0"), false, false);
+    EXPECT_EQ_OK("a4/b4/foo/bar/1.0/", coordinator.getPackagePath, FQName("a.c.foo.bar@1.0::IFoo"),
+                 false, false);
+    EXPECT_EQ_OK("a1/b1/foo/V1_0/", coordinator.getPackagePath, FQName("a.b.foo@1.0"), false, true);
+    EXPECT_EQ_OK("a4/b4/foo/bar/V1_0/", coordinator.getPackagePath, FQName("a.c.foo.bar@1.0::IFoo"),
+                 false, true);
+    EXPECT_EQ_OK("foo/1.0/", coordinator.getPackagePath, FQName("a.b.foo@1.0"), true, false);
+    EXPECT_EQ_OK("foo/bar/1.0/", coordinator.getPackagePath, FQName("a.c.foo.bar@1.0::IFoo"), true,
+                 false);
+    EXPECT_EQ_OK("foo/V1_0/", coordinator.getPackagePath, FQName("a.b.foo@1.0"), true, true);
+    EXPECT_EQ_OK("foo/bar/V1_0/", coordinator.getPackagePath, FQName("a.c.foo.bar@1.0::IFoo"), true,
+                 true);
+}
+
+TEST_F(HidlGenHostTest, CoordinatorFilepathTest) {
+    using Location = Coordinator::Location;
+
+    Coordinator coordinator;
+    coordinator.setOutputPath("foo/");
+    coordinator.setRootPath("bar/");
+
+    std::string error;
+    EXPECT_EQ(OK, coordinator.addPackagePath("a.b", "a1/b1", &error));
+    EXPECT_TRUE(error.empty());
+
+    const static FQName kName = FQName("a.b.c@1.2");
+
+    // get file names
+    EXPECT_EQ_OK("foo/x.y", coordinator.getFilepath, kName, Location::DIRECT, "x.y");
+    EXPECT_EQ_OK("foo/a1/b1/c/1.2/x.y", coordinator.getFilepath, kName, Location::PACKAGE_ROOT,
+                 "x.y");
+    EXPECT_EQ_OK("foo/a/b/c/1.2/x.y", coordinator.getFilepath, kName, Location::GEN_OUTPUT, "x.y");
+    EXPECT_EQ_OK("foo/a/b/c/V1_2/x.y", coordinator.getFilepath, kName, Location::GEN_SANITIZED,
+                 "x.y");
+
+    // get directories
+    EXPECT_EQ_OK("foo/", coordinator.getFilepath, kName, Location::DIRECT, "");
+    EXPECT_EQ_OK("foo/a1/b1/c/1.2/", coordinator.getFilepath, kName, Location::PACKAGE_ROOT, "");
+    EXPECT_EQ_OK("foo/a/b/c/1.2/", coordinator.getFilepath, kName, Location::GEN_OUTPUT, "");
+    EXPECT_EQ_OK("foo/a/b/c/V1_2/", coordinator.getFilepath, kName, Location::GEN_SANITIZED, "");
+}
+
+TEST_F(HidlGenHostTest, LocationTest) {
+    Location a{{"file", 3, 4}, {"file", 3, 5}};
+    Location b{{"file", 3, 6}, {"file", 3, 7}};
+    Location c{{"file", 4, 4}, {"file", 4, 5}};
+
+    Location other{{"other", 0, 0}, {"other", 0, 1}};
+
+    EXPECT_LT(a, b);
+    EXPECT_LT(b, c);
+    EXPECT_LT(a, c);
+    EXPECT_FALSE(Location::inSameFile(a, other));
+}
+
+int main(int argc, char **argv) {
+    ::testing::InitGoogleTest(&argc, argv);
+    return RUN_ALL_TESTS();
+}
+
+}  // namespace android
\ No newline at end of file
diff --git a/test/impl_test/Android.bp b/test/impl_test/Android.bp
index b220f24..a440eb9 100644
--- a/test/impl_test/Android.bp
+++ b/test/impl_test/Android.bp
@@ -42,4 +42,9 @@
         "libutils",
         "android.hardware.tests.foo@1.0",
     ],
+    cflags: [
+        "-Wall",
+        "-Werror",
+        "-Wno-unused-parameter",
+    ],
 }
diff --git a/test/java_test/Android.bp b/test/java_test/Android.bp
index 23bdf08..f7b731d 100644
--- a/test/java_test/Android.bp
+++ b/test/java_test/Android.bp
@@ -2,6 +2,8 @@
     name: "hidl_test_java_native",
     srcs: ["hidl_test_java_native.cpp"],
 
+    cflags: ["-Wall", "-Werror"],
+
     shared_libs: [
         "libbase",
         "libhidlbase",
diff --git a/test/java_test/Android.mk b/test/java_test/Android.mk
index 1f2e868..a41fa5d 100644
--- a/test/java_test/Android.mk
+++ b/test/java_test/Android.mk
@@ -7,6 +7,7 @@
 LOCAL_MODULE_CLASS := JAVA_LIBRARIES
 LOCAL_JAVA_LIBRARIES :=                          \
     android.hidl.base-V1.0-java                  \
+    android.hidl.manager-V1.0-java               \
     android.hardware.tests.baz-V1.0-java         \
     android.hardware.tests.expression-V1.0-java  \
     android.hardware.tests.inheritance-V1.0-java
@@ -20,13 +21,15 @@
 LOCAL_MODULE_CLASS := NATIVE_TESTS
 LOCAL_SRC_FILES := hidl_test_java
 
-LOCAL_ADDITIONAL_DEPENDENCIES :=                \
-    hidl_test_java_lib                          \
-    hidl_test_java_native                       \
-
 LOCAL_REQUIRED_MODULES :=                       \
     hidl_test_java_lib                          \
+    hidl_test_java_native                       \
     android.hidl.base-V1.0-java                 \
+    android.hidl.manager-V1.0-java              \
     android.hardware.tests.baz-V1.0-java
 
+LOCAL_REQUIRED_MODULES_arm64 := hidl_test_java_native_32
+LOCAL_REQUIRED_MODULES_x86_64 := hidl_test_java_native_32
+LOCAL_REQUIRED_MODULES_mips64 := hidl_test_java_native_32
+
 include $(BUILD_PREBUILT)
diff --git a/test/java_test/hidl_test_java b/test/java_test/hidl_test_java
index 2076d00..1cdfb3f 100644
--- a/test/java_test/hidl_test_java
+++ b/test/java_test/hidl_test_java
@@ -22,7 +22,6 @@
         # Test Java server with native client
         app_process $base/bin com.android.commands.hidl_test_java.HidlTestJava -s &
         NATIVE_PID=$!
-        sleep 1
         $native -c \
             && echo "native client => Java server PASSED" \
             || (echo "native client => Java server FAILED" && false) || e=1
@@ -38,4 +37,4 @@
 echo "Summary: $e"
 [ $e -eq 0 ] && echo "All tests PASSED." || echo "Test(s) FAILED."
 
-exit $e
\ No newline at end of file
+exit $e
diff --git a/test/java_test/hidl_test_java_native.cpp b/test/java_test/hidl_test_java_native.cpp
index 0d3a7c3..d155e09 100644
--- a/test/java_test/hidl_test_java_native.cpp
+++ b/test/java_test/hidl_test_java_native.cpp
@@ -22,7 +22,7 @@
 #include <android/hardware/tests/baz/1.0/IBaz.h>
 
 #include <hidl/LegacySupport.h>
-
+#include <hidl/ServiceManagement.h>
 #include <gtest/gtest.h>
 
 #include <hidl/HidlTransportSupport.h>
@@ -77,9 +77,13 @@
     void SetUp() override {
         using namespace ::android::hardware;
 
+        ::android::hardware::details::waitForHwService(
+                IBaz::descriptor, "baz");
+
         baz = IBaz::getService("baz");
 
         CHECK(baz != NULL);
+        CHECK(baz->isRemote());
     }
 
     void TearDown() override {
@@ -489,6 +493,87 @@
                 }));
 }
 
+TEST_F(HidlTest, BazTestArrays) {
+    IBase::LotsOfPrimitiveArrays in;
+
+    for (size_t i = 0; i < 128; ++i) {
+        in.byte1[i] = i;
+        in.boolean1[i] = (i & 4) != 0;
+        in.double1[i] = i;
+    }
+
+    size_t k = 0;
+    for (size_t i = 0; i < 8; ++i) {
+        for (size_t j = 0; j < 128; ++j, ++k) {
+            in.byte2[i][j] = k;
+            in.boolean2[i][j] = (k & 4) != 0;
+            in.double2[i][j] = k;
+        }
+    }
+
+    size_t m = 0;
+    for (size_t i = 0; i < 8; ++i) {
+        for (size_t j = 0; j < 16; ++j) {
+            for (size_t k = 0; k < 128; ++k, ++m) {
+                in.byte3[i][j][k] = m;
+                in.boolean3[i][j][k] = (m & 4) != 0;
+                in.double3[i][j][k] = m;
+            }
+        }
+    }
+
+    EXPECT_OK(
+            baz->testArrays(in,
+                [&](const auto &out) {
+                    EXPECT_EQ(in, out);
+                }));
+}
+
+TEST_F(HidlTest, BazTestByteVecs) {
+    hidl_vec<IBase::ByteOneDim> in;
+    in.resize(8);
+
+    size_t k = 0;
+    for (size_t i = 0; i < in.size(); ++i) {
+        for (size_t j = 0; j < 128; ++j, ++k) {
+            in[i][j] = k;
+        }
+    }
+
+    EXPECT_OK(baz->testByteVecs(
+                in, [&](const auto &out) { EXPECT_EQ(in, out); }));
+}
+
+TEST_F(HidlTest, BazTestBooleanVecs) {
+    hidl_vec<IBase::BooleanOneDim> in;
+    in.resize(8);
+
+    size_t k = 0;
+    for (size_t i = 0; i < in.size(); ++i) {
+        for (size_t j = 0; j < 128; ++j, ++k) {
+            in[i][j] = (k & 4) != 0;
+        }
+    }
+
+    EXPECT_OK(baz->testBooleanVecs(
+                in, [&](const auto &out) { EXPECT_EQ(in, out); }));
+}
+
+TEST_F(HidlTest, BazTestDoubleVecs) {
+    hidl_vec<IBase::DoubleOneDim> in;
+    in.resize(8);
+
+    size_t k = 0;
+    for (size_t i = 0; i < in.size(); ++i) {
+        for (size_t j = 0; j < 128; ++j, ++k) {
+            in[i][j] = k;
+        }
+    }
+
+    EXPECT_OK(baz->testDoubleVecs(
+                in, [&](const auto &out) { EXPECT_EQ(in, out); }));
+}
+
 int main(int argc, char **argv) {
     setenv("TREBLE_TESTING_OVERRIDE", "true", true);
 
diff --git a/test/java_test/src/com/android/commands/hidl_test_java/HidlTestJava.java b/test/java_test/src/com/android/commands/hidl_test_java/HidlTestJava.java
index 16dc793..f670732 100644
--- a/test/java_test/src/com/android/commands/hidl_test_java/HidlTestJava.java
+++ b/test/java_test/src/com/android/commands/hidl_test_java/HidlTestJava.java
@@ -16,6 +16,7 @@
 
 package com.android.commands.hidl_test_java;
 
+import android.hidl.manager.V1_0.IServiceManager;
 import android.hardware.tests.baz.V1_0.IBase;
 import android.hardware.tests.baz.V1_0.IBaz;
 import android.hardware.tests.baz.V1_0.IQuux;
@@ -29,6 +30,7 @@
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.NoSuchElementException;
+import java.util.Objects;
 
 public final class HidlTestJava {
     private static final String TAG = "HidlTestJava";
@@ -115,6 +117,20 @@
         throw new RuntimeException();
     }
 
+    // .equals and HidlSupport.interfacesEqual should have the same behavior.
+    private void ExpectEqual(android.hidl.base.V1_0.IBase l, android.hidl.base.V1_0.IBase r) {
+        ExpectTrue(Objects.equals(l, r));
+        ExpectTrue(Objects.equals(r, l));
+        ExpectTrue(HidlSupport.interfacesEqual(l, r));
+        ExpectTrue(HidlSupport.interfacesEqual(r, l));
+    }
+    private void ExpectNotEqual(android.hidl.base.V1_0.IBase l, android.hidl.base.V1_0.IBase r) {
+        ExpectFalse(Objects.equals(l, r));
+        ExpectFalse(Objects.equals(r, l));
+        ExpectFalse(HidlSupport.interfacesEqual(l, r));
+        ExpectFalse(HidlSupport.interfacesEqual(r, l));
+    }
+
     class BazCallback extends IBazCallback.Stub {
         private boolean mCalled;
 
@@ -135,6 +151,12 @@
         public void hey() {
             mCalled = true;
         }
+
+        @Override public boolean equals(Object other) {
+            return other != null && other.getClass() == BazCallback.class &&
+                ((BazCallback) other).mCalled == mCalled;
+        }
+        @Override public int hashCode() { return mCalled ? 1 : 0; }
     }
 
     private String numberToEnglish(int x) {
@@ -240,6 +262,8 @@
             // Test proper exceptions are thrown
             try {
                 IBase proxy = IBase.getService("this-doesn't-exist");
+                // this should never run
+                ExpectTrue(false);
             } catch (Exception e) {
                 ExpectTrue(e instanceof NoSuchElementException);
             }
@@ -259,7 +283,18 @@
             ExpectTrue(quuxProxy == null);
         }
 
+        {
+            // Test waiting API
+            IBase baseProxyA = IBaz.getService("baz", true /* retry */);
+            ExpectTrue(baseProxyA != null);
+            IBase baseProxyB = IBaz.getService("baz", false /* retry */);
+            ExpectTrue(baseProxyB != null);
+        }
+
         IBaz proxy = IBaz.getService("baz");
+
+        proxy.ping();
+
         proxy.someBaseMethod();
 
         {
@@ -630,6 +665,142 @@
             }
         }
 
+        {
+            // TestArrays
+            IBase.LotsOfPrimitiveArrays in = new IBase.LotsOfPrimitiveArrays();
+
+            for (int i = 0; i < 128; ++i) {
+                in.byte1[i] = (byte)i;
+                in.boolean1[i] = (i & 4) != 0;
+                in.double1[i] = i;
+            }
+
+            int m = 0;
+            for (int i = 0; i < 8; ++i) {
+                for (int j = 0; j < 128; ++j, ++m) {
+                    in.byte2[i][j] = (byte)m;
+                    in.boolean2[i][j] = (m & 4) != 0;
+                    in.double2[i][j] = m;
+                }
+            }
+
+            m = 0;
+            for (int i = 0; i < 8; ++i) {
+                for (int j = 0; j < 16; ++j) {
+                    for (int k = 0; k < 128; ++k, ++m) {
+                        in.byte3[i][j][k] = (byte)m;
+                        in.boolean3[i][j][k] = (m & 4) != 0;
+                        in.double3[i][j][k] = m;
+                    }
+                }
+            }
+
+            IBase.LotsOfPrimitiveArrays out = proxy.testArrays(in);
+            ExpectTrue(in.equals(out));
+        }
+
+        {
+            // testByteVecs
+
+            ArrayList<byte[]> in = new ArrayList<byte[]>();
+
+            int k = 0;
+            for (int i = 0; i < in.size(); ++i) {
+                byte[] elem = new byte[128];
+                for (int j = 0; j < 128; ++j, ++k) {
+                    elem[j] = (byte)k;
+                }
+                in.add(elem);
+            }
+
+            ArrayList<byte[]> out = proxy.testByteVecs(in);
+            ExpectTrue(in.equals(out));
+        }
+
+        {
+            // testBooleanVecs
+
+            ArrayList<boolean[]> in = new ArrayList<boolean[]>();
+
+            int k = 0;
+            for (int i = 0; i < in.size(); ++i) {
+                boolean[] elem = new boolean[128];
+                for (int j = 0; j < 128; ++j, ++k) {
+                    elem[j] = (k & 4) != 0;
+                }
+                in.add(elem);
+            }
+
+            ArrayList<boolean[]> out = proxy.testBooleanVecs(in);
+            ExpectTrue(in.equals(out));
+        }
+
+        {
+            // testDoubleVecs
+
+            ArrayList<double[]> in = new ArrayList<double[]>();
+
+            int k = 0;
+            for (int i = 0; i < in.size(); ++i) {
+                double[] elem = new double[128];
+                for (int j = 0; j < 128; ++j, ++k) {
+                    elem[j] = k;
+                }
+                in.add(elem);
+            }
+
+            ArrayList<double[]> out = proxy.testDoubleVecs(in);
+            ExpectTrue(in.equals(out));
+        }
+
+        {
+            // testProxyEquals
+            // TODO(b/68727931): test passthrough services as well.
+
+            IBase proxy1 = IBase.getService("baz");
+            IBase proxy2 = IBase.getService("baz");
+            IBaz proxy3 = IBaz.getService("baz");
+            IBazCallback callback1 = new BazCallback();
+            IBazCallback callback2 = new BazCallback();
+            IServiceManager manager = IServiceManager.getService();
+
+            // test hwbinder proxies
+            ExpectEqual(proxy1, proxy2); // same proxy class
+            ExpectEqual(proxy1, proxy3); // different proxy class
+
+            // negative tests
+            ExpectNotEqual(proxy1, null);
+            ExpectNotEqual(proxy1, callback1); // proxy != stub
+            ExpectNotEqual(proxy1, manager);
+
+            // HidlSupport.interfacesEqual use overridden .equals for stubs
+            ExpectEqual(callback1, callback1);
+            ExpectEqual(callback1, callback2);
+            callback1.hey();
+            ExpectNotEqual(callback1, callback2);
+            callback2.hey();
+            ExpectEqual(callback1, callback2);
+
+            // test hash for proxies
+            java.util.HashSet<IBase> set = new java.util.HashSet<>();
+            set.add(proxy1);
+            ExpectTrue(set.contains(proxy1)); // hash is stable
+            ExpectTrue(set.contains(proxy2));
+            ExpectFalse(set.contains(manager));
+        }
+        {
+            IBaz baz = IBaz.getService("baz");
+            ExpectTrue(baz != null);
+            IBaz.StructWithInterface swi = new IBaz.StructWithInterface();
+            swi.dummy = baz;
+            swi.number = 12345678;
+            IBaz.StructWithInterface swi_back = baz.haveSomeStructWithInterface(swi);
+            ExpectTrue(swi_back != null);
+            ExpectTrue(swi_back.dummy != null);
+            ExpectTrue(HidlSupport.interfacesEqual(baz, swi_back.dummy));
+            ExpectTrue(swi_back.number == 12345678);
+        }
+
         // --- DEATH RECIPIENT TESTING ---
         // This must always be done last, since it will kill the native server process
         HidlDeathRecipient recipient1 = new HidlDeathRecipient();
@@ -817,6 +988,22 @@
                     (byte)(second.value & bf), (byte)((bf | bf) & third));
         }
 
+        public LotsOfPrimitiveArrays testArrays(LotsOfPrimitiveArrays in) {
+            return in;
+        }
+
+        public ArrayList<byte[]> testByteVecs(ArrayList<byte[]> in) {
+            return in;
+        }
+
+        public ArrayList<boolean[]> testBooleanVecs(ArrayList<boolean[]> in) {
+            return in;
+        }
+
+        public ArrayList<double[]> testDoubleVecs(ArrayList<double[]> in) {
+            return in;
+        }
+
         public byte returnABitField() {
             return 0;
         }
@@ -894,6 +1081,10 @@
         public void returnABunchOfStrings(returnABunchOfStringsCallback cb) {
             cb.onValues("Eins", "Zwei", "Drei");
         }
+
+        public StructWithInterface haveSomeStructWithInterface(StructWithInterface swi) {
+            return swi;
+        }
     }
 
     private void server() throws RemoteException {
diff --git a/test/run_all_device_tests.sh b/test/run_all_device_tests.sh
new file mode 100755
index 0000000..a32558a
--- /dev/null
+++ b/test/run_all_device_tests.sh
@@ -0,0 +1,56 @@
+#!/bin/bash
+
+function run() {
+    local FAILED_TESTS=()
+
+    # Tests directly relevant to HIDL infrustructure but aren't
+    # located in system/tools/hidl
+    local RELATED_RUNTIME_TESTS=(\
+        libhidl_test \
+    )
+
+    local RUN_TIME_TESTS=(\
+        libhidl-gen-utils_test \
+    )
+    RUN_TIME_TESTS+=(${RELATED_RUNTIME_TESTS[@]})
+
+    local SCRIPT_TESTS=(\
+        hidl_test\
+        hidl_test_java\
+        fmq_test\
+    )
+
+    $ANDROID_BUILD_TOP/build/soong/soong_ui.bash --make-mode -j \
+        ${RUN_TIME_TESTS[*]} ${SCRIPT_TESTS[*]} || return
+
+    adb sync || return
+
+    local BITNESS=("nativetest" "nativetest64")
+
+    for test in ${RUN_TIME_TESTS[@]}; do
+        for bits in ${BITNESS[@]}; do
+            echo $bits $test
+            adb shell /data/$bits/$test/$test ||
+                FAILED_TESTS+=("$bits:$test")
+        done
+    done
+
+    for test in ${SCRIPT_TESTS[@]}; do
+        echo $test
+        adb shell /data/nativetest64/$test ||
+            FAILED_TESTS+=("$test")
+    done
+
+    echo
+    echo ===== ALL DEVICE TESTS SUMMARY =====
+    echo
+    if [ ${#FAILED_TESTS[@]} -gt 0 ]; then
+        for failed in ${FAILED_TESTS[@]}; do
+            echo "FAILED TEST: $failed"
+        done
+    else
+        echo "SUCCESS"
+    fi
+}
+
+run
\ No newline at end of file
diff --git a/test/run_all_host_tests.sh b/test/run_all_host_tests.sh
new file mode 100755
index 0000000..442efd7
--- /dev/null
+++ b/test/run_all_host_tests.sh
@@ -0,0 +1,44 @@
+#!/bin/bash
+
+function run() {
+    local FAILED_TESTS=()
+
+    local COMPILE_TIME_TESTS=(\
+        hidl_error_test \
+        hidl_export_test \
+        hidl_hash_test \
+        hidl_impl_test \
+        android.hardware.tests.foo@1.0-vts.driver \
+        android.hardware.tests.foo@1.0-vts.profiler)
+
+    local RUN_TIME_TESTS=(\
+        libhidl-gen-utils_test \
+        hidl-gen-host_test \
+    )
+
+    $ANDROID_BUILD_TOP/build/soong/soong_ui.bash --make-mode -j \
+        ${COMPILE_TIME_TESTS[*]} ${RUN_TIME_TESTS[*]} || return
+
+    local BITNESS=("nativetest" "nativetest64")
+
+    for bits in ${BITNESS[@]}; do
+        for test in ${RUN_TIME_TESTS[@]}; do
+            echo $bits $test
+            $ANDROID_BUILD_TOP/out/host/linux-x86/$bits/$test/$test ||
+                FAILED_TESTS+=("$bits:$test")
+        done
+    done
+
+    echo
+    echo ===== ALL HOST TESTS SUMMARY =====
+    echo
+    if [ ${#FAILED_TESTS[@]} -gt 0 ]; then
+        for failed in ${FAILED_TESTS[@]}; do
+            echo "FAILED TEST: $failed"
+        done
+    else
+        echo "SUCCESS"
+    fi
+}
+
+run
\ No newline at end of file
diff --git a/test/utils_test/Android.bp b/test/utils_test/Android.bp
new file mode 100644
index 0000000..8637a17
--- /dev/null
+++ b/test/utils_test/Android.bp
@@ -0,0 +1,25 @@
+// Copyright (C) 2017 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.
+
+cc_test {
+    name: "libhidl-gen-utils_test",
+    defaults: ["hidl-gen-defaults"],
+    host_supported: true,
+
+    shared_libs: [
+        "libhidl-gen-utils",
+    ],
+
+    srcs: ["main.cpp"],
+}
\ No newline at end of file
diff --git a/test/utils_test/main.cpp b/test/utils_test/main.cpp
new file mode 100644
index 0000000..b2c8576
--- /dev/null
+++ b/test/utils_test/main.cpp
@@ -0,0 +1,196 @@
+/*
+ * Copyright (C) 2016 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.
+ */
+
+#define LOG_TAG "libhidl-gen-utils"
+
+#include <hidl-util/FqInstance.h>
+#include <hidl-util/StringHelper.h>
+
+#include <gtest/gtest.h>
+#include <vector>
+
+using ::android::FqInstance;
+using ::android::StringHelper;
+
+class LibHidlGenUtilsTest : public ::testing::Test {};
+
+TEST_F(LibHidlGenUtilsTest, EndsWithTest) {
+    EXPECT_TRUE(StringHelper::EndsWith("", ""));
+    EXPECT_TRUE(StringHelper::EndsWith("a", ""));
+    EXPECT_TRUE(StringHelper::EndsWith("b", "b"));
+    EXPECT_TRUE(StringHelper::EndsWith("ab", "b"));
+    EXPECT_TRUE(StringHelper::EndsWith("ab", "ab"));
+    EXPECT_TRUE(StringHelper::EndsWith("abcd", "bcd"));
+    EXPECT_TRUE(StringHelper::EndsWith("abcd", "abcd"));
+    EXPECT_TRUE(StringHelper::EndsWith("abcdefghijk", "ijk"));
+    EXPECT_TRUE(StringHelper::EndsWith("abcdefghijk", "bcdefghijk"));
+
+    EXPECT_FALSE(StringHelper::EndsWith("", "a"));
+    EXPECT_FALSE(StringHelper::EndsWith("b", "a"));
+    EXPECT_FALSE(StringHelper::EndsWith("abcd", "ab"));
+}
+
+TEST_F(LibHidlGenUtilsTest, StartsWithTest) {
+    EXPECT_TRUE(StringHelper::StartsWith("", ""));
+    EXPECT_TRUE(StringHelper::StartsWith("a", ""));
+    EXPECT_TRUE(StringHelper::StartsWith("b", "b"));
+    EXPECT_TRUE(StringHelper::StartsWith("ab", "a"));
+    EXPECT_TRUE(StringHelper::StartsWith("ab", "ab"));
+    EXPECT_TRUE(StringHelper::StartsWith("abcd", "abc"));
+    EXPECT_TRUE(StringHelper::StartsWith("abcd", "abcd"));
+    EXPECT_TRUE(StringHelper::StartsWith("abcdefghijk", "abc"));
+    EXPECT_TRUE(StringHelper::StartsWith("abcdefghijk", "abcdefghij"));
+
+    EXPECT_FALSE(StringHelper::StartsWith("", "a"));
+    EXPECT_FALSE(StringHelper::StartsWith("b", "a"));
+    EXPECT_FALSE(StringHelper::StartsWith("abcd", "cd"));
+}
+
+TEST_F(LibHidlGenUtilsTest, Trim) {
+    EXPECT_EQ("", StringHelper::LTrim("", ""));
+    EXPECT_EQ("", StringHelper::LTrim("", "a"));
+    EXPECT_EQ("", StringHelper::LTrim("a", "a"));
+    EXPECT_EQ("a", StringHelper::LTrim("a", ""));
+    EXPECT_EQ("a", StringHelper::LTrim("a", "b"));
+    EXPECT_EQ("a", StringHelper::LTrim("ba", "b"));
+    EXPECT_EQ("f", StringHelper::LTrim("abcdef", "abcde"));
+    EXPECT_EQ("cdef", StringHelper::LTrim("abcdef", "ab"));
+    EXPECT_EQ("abcdef", StringHelper::LTrim("abcdef", ""));
+
+    EXPECT_EQ("", StringHelper::RTrim("", ""));
+    EXPECT_EQ("", StringHelper::RTrim("", "a"));
+    EXPECT_EQ("", StringHelper::RTrim("a", "a"));
+    EXPECT_EQ("a", StringHelper::RTrim("a", ""));
+    EXPECT_EQ("a", StringHelper::RTrim("a", "b"));
+    EXPECT_EQ("a", StringHelper::RTrim("ab", "b"));
+    EXPECT_EQ("a", StringHelper::RTrim("abcdef", "bcdef"));
+    EXPECT_EQ("abcd", StringHelper::RTrim("abcdef", "ef"));
+    EXPECT_EQ("abcdef", StringHelper::RTrim("abcdef", ""));
+}
+
+TEST_F(LibHidlGenUtilsTest, TrimAll) {
+    EXPECT_EQ("", StringHelper::LTrimAll("", ""));
+    EXPECT_EQ("", StringHelper::LTrimAll("", "a"));
+    EXPECT_EQ("", StringHelper::LTrimAll("", "ab"));
+    EXPECT_EQ("", StringHelper::LTrimAll("a", "a"));
+    EXPECT_EQ("", StringHelper::LTrimAll("aa", "a"));
+    EXPECT_EQ("b", StringHelper::LTrimAll("b", "a"));
+    EXPECT_EQ("b", StringHelper::LTrimAll("aaab", "a"));
+    EXPECT_EQ("c", StringHelper::LTrimAll("ababc", "ab"));
+    EXPECT_EQ("ac", StringHelper::LTrimAll("abac", "ab"));
+
+    EXPECT_EQ("", StringHelper::RTrimAll("", ""));
+    EXPECT_EQ("", StringHelper::RTrimAll("", "a"));
+    EXPECT_EQ("", StringHelper::RTrimAll("", "ab"));
+    EXPECT_EQ("", StringHelper::RTrimAll("a", "a"));
+    EXPECT_EQ("", StringHelper::RTrimAll("aa", "a"));
+    EXPECT_EQ("b", StringHelper::RTrimAll("b", "a"));
+    EXPECT_EQ("b", StringHelper::RTrimAll("baaa", "a"));
+    EXPECT_EQ("c", StringHelper::RTrimAll("cabab", "ab"));
+    EXPECT_EQ("ca", StringHelper::RTrimAll("caba", "ba"));
+}
+
+TEST_F(LibHidlGenUtilsTest, SplitString) {
+    std::vector<std::string> components;
+
+    StringHelper::SplitString("", '.', &components);
+    EXPECT_EQ(std::vector<std::string>({""}), components);
+    StringHelper::SplitString("a.", '.', &components);
+    EXPECT_EQ(std::vector<std::string>({"a", ""}), components);
+    StringHelper::SplitString(".a", '.', &components);
+    EXPECT_EQ(std::vector<std::string>({"", "a"}), components);
+    StringHelper::SplitString("..", '.', &components);
+    EXPECT_EQ(std::vector<std::string>({"", "", ""}), components);
+    StringHelper::SplitString("asdf.asdf", '.', &components);
+    EXPECT_EQ(std::vector<std::string>({"asdf", "asdf"}), components);
+}
+
+TEST_F(LibHidlGenUtilsTest, JoinStrings) {
+    EXPECT_EQ("", StringHelper::JoinStrings({}, ""));
+    EXPECT_EQ("", StringHelper::JoinStrings({}, "a"));
+    EXPECT_EQ("a", StringHelper::JoinStrings({"a"}, ""));
+    EXPECT_EQ("a,b", StringHelper::JoinStrings({"a", "b"}, ","));
+    EXPECT_EQ("ab,", StringHelper::JoinStrings({"ab", ""}, ","));
+    EXPECT_EQ(",ab", StringHelper::JoinStrings({"", "ab"}, ","));
+    EXPECT_EQ("a.,b", StringHelper::JoinStrings({"a", "b"}, ".,"));
+    EXPECT_EQ("a,b,c", StringHelper::JoinStrings({"a", "b", "c"}, ","));
+    EXPECT_EQ("abc.,def.,ghi", StringHelper::JoinStrings({"abc", "def", "ghi"}, ".,"));
+}
+
+TEST_F(LibHidlGenUtilsTest, FqInstance1) {
+    FqInstance e;
+    ASSERT_TRUE(e.setTo("android.hardware.foo@1.0::IFoo/instance"));
+    EXPECT_EQ("android.hardware.foo@1.0::IFoo/instance", e.string());
+    ASSERT_TRUE(e.hasPackage());
+    EXPECT_EQ("android.hardware.foo", e.getPackage());
+    ASSERT_TRUE(e.hasVersion());
+    EXPECT_EQ(1u, e.getMajorVersion());
+    EXPECT_EQ(0u, e.getMinorVersion());
+    EXPECT_EQ((std::make_pair<size_t, size_t>(1u, 0u)), e.getVersion());
+    ASSERT_TRUE(e.hasInterface());
+    EXPECT_EQ("IFoo", e.getInterface());
+    ASSERT_TRUE(e.hasInstance());
+    EXPECT_EQ("instance", e.getInstance());
+}
+
+TEST_F(LibHidlGenUtilsTest, FqInstance2) {
+    FqInstance e;
+    ASSERT_TRUE(e.setTo("@1.0::IFoo/instance"));
+    EXPECT_EQ("@1.0::IFoo/instance", e.string());
+    ASSERT_FALSE(e.hasPackage());
+    ASSERT_TRUE(e.hasVersion());
+    EXPECT_EQ((std::make_pair<size_t, size_t>(1u, 0u)), e.getVersion());
+    ASSERT_TRUE(e.hasInterface());
+    EXPECT_EQ("IFoo", e.getInterface());
+    ASSERT_TRUE(e.hasInstance());
+    EXPECT_EQ("instance", e.getInstance());
+}
+
+TEST_F(LibHidlGenUtilsTest, FqInstance3) {
+    FqInstance e;
+    ASSERT_TRUE(e.setTo("IFoo/instance"));
+    EXPECT_EQ("IFoo/instance", e.string());
+    ASSERT_FALSE(e.hasPackage());
+    ASSERT_FALSE(e.hasVersion());
+    ASSERT_TRUE(e.hasInterface());
+    EXPECT_EQ("IFoo", e.getInterface());
+    ASSERT_TRUE(e.hasInstance());
+    EXPECT_EQ("instance", e.getInstance());
+}
+
+TEST_F(LibHidlGenUtilsTest, FqInstanceFqNameOnly) {
+    FqInstance e;
+    for (auto testString :
+         {"android.hardware.foo@1.0::IFoo.Type", "@1.0::IFoo.Type", "android.hardware.foo@1.0",
+          "IFoo.Type", "Type", "android.hardware.foo@1.0::IFoo.Type:MY_ENUM_VALUE",
+          "@1.0::IFoo.Type:MY_ENUM_VALUE", "IFoo.Type:MY_ENUM_VALUE"}) {
+        ASSERT_TRUE(e.setTo(testString));
+        EXPECT_EQ(testString, e.string());
+        ASSERT_FALSE(e.hasInstance());
+    };
+}
+
+TEST_F(LibHidlGenUtilsTest, FqInstanceIdentifier) {
+    FqInstance e;
+    ASSERT_TRUE(e.setTo("Type"));
+    EXPECT_EQ("Type", e.string());
+    ASSERT_FALSE(e.hasInstance());
+}
+
+int main(int argc, char **argv) {
+    ::testing::InitGoogleTest(&argc, argv);
+    return RUN_ALL_TESTS();
+}
diff --git a/test/vendor/1.0/Android.bp b/test/vendor/1.0/Android.bp
index f640216..8519fa5 100644
--- a/test/vendor/1.0/Android.bp
+++ b/test/vendor/1.0/Android.bp
@@ -1,90 +1,23 @@
-// This file is autogenerated by hidl-gen. Do not edit manually.
+// This file is autogenerated by hidl-gen -Landroidbp.
 
-filegroup {
-    name: "tests.vendor@1.0_hal",
+hidl_interface {
+    name: "hidl.tests.vendor@1.0",
+    owner: "some-owner-name",
+    root: "hidl.tests",
     srcs: [
         "types.hal",
         "IVendor.hal",
     ],
+    interfaces: [
+        "android.hardware.tests.baz@1.0",
+        "android.hidl.base@1.0",
+    ],
+    types: [
+        "Bar",
+        "Foo",
+        "FooToo",
+    ],
+    gen_java: true,
+    gen_java_constants: true,
 }
 
-genrule {
-    name: "tests.vendor@1.0_genc++",
-    tools: ["hidl-gen"],
-    cmd: "$(location hidl-gen) -o $(genDir) -Lc++-sources -randroid.hardware:hardware/interfaces -randroid.hidl:system/libhidl/transport -rtests:system/tools/hidl/test/ tests.vendor@1.0",
-    srcs: [
-        ":tests.vendor@1.0_hal",
-    ],
-    out: [
-        "tests/vendor/1.0/types.cpp",
-        "tests/vendor/1.0/VendorAll.cpp",
-    ],
-}
-
-genrule {
-    name: "tests.vendor@1.0_genc++_headers",
-    tools: ["hidl-gen"],
-    cmd: "$(location hidl-gen) -o $(genDir) -Lc++-headers -randroid.hardware:hardware/interfaces -randroid.hidl:system/libhidl/transport -rtests:system/tools/hidl/test/ tests.vendor@1.0",
-    srcs: [
-        ":tests.vendor@1.0_hal",
-    ],
-    out: [
-        "tests/vendor/1.0/types.h",
-        "tests/vendor/1.0/hwtypes.h",
-        "tests/vendor/1.0/IVendor.h",
-        "tests/vendor/1.0/IHwVendor.h",
-        "tests/vendor/1.0/BnHwVendor.h",
-        "tests/vendor/1.0/BpHwVendor.h",
-        "tests/vendor/1.0/BsVendor.h",
-    ],
-}
-
-cc_library {
-    name: "tests.vendor@1.0",
-    defaults: ["hidl-module-defaults"],
-    generated_sources: ["tests.vendor@1.0_genc++"],
-    generated_headers: ["tests.vendor@1.0_genc++_headers"],
-    export_generated_headers: ["tests.vendor@1.0_genc++_headers"],
-    vendor_available: true,
-    shared_libs: [
-        "libhidlbase",
-        "libhidltransport",
-        "libhwbinder",
-        "liblog",
-        "libutils",
-        "libcutils",
-        "android.hardware.tests.baz@1.0",
-    ],
-    export_shared_lib_headers: [
-        "libhidlbase",
-        "libhidltransport",
-        "libhwbinder",
-        "libutils",
-        "android.hardware.tests.baz@1.0",
-    ],
-}
-
-cc_library {
-    name: "tests.vendor@1.0_vendor",
-    defaults: ["hidl-module-defaults"],
-    generated_sources: ["tests.vendor@1.0_genc++"],
-    generated_headers: ["tests.vendor@1.0_genc++_headers"],
-    export_generated_headers: ["tests.vendor@1.0_genc++_headers"],
-    vendor: true,
-    shared_libs: [
-        "libhidlbase",
-        "libhidltransport",
-        "libhwbinder",
-        "liblog",
-        "libutils",
-        "libcutils",
-        "android.hardware.tests.baz@1.0",
-    ],
-    export_shared_lib_headers: [
-        "libhidlbase",
-        "libhidltransport",
-        "libhwbinder",
-        "libutils",
-        "android.hardware.tests.baz@1.0",
-    ],
-}
diff --git a/test/vendor/1.0/Android.mk b/test/vendor/1.0/Android.mk
deleted file mode 100644
index 5caa041..0000000
--- a/test/vendor/1.0/Android.mk
+++ /dev/null
@@ -1,235 +0,0 @@
-# This file is autogenerated by hidl-gen. Do not edit manually.
-
-LOCAL_PATH := $(call my-dir)
-
-################################################################################
-
-include $(CLEAR_VARS)
-LOCAL_MODULE := tests.vendor-V1.0-java
-LOCAL_MODULE_CLASS := JAVA_LIBRARIES
-
-intermediates := $(call local-generated-sources-dir, COMMON)
-
-HIDL := $(HOST_OUT_EXECUTABLES)/hidl-gen$(HOST_EXECUTABLE_SUFFIX)
-
-LOCAL_JAVA_LIBRARIES := \
-    android.hardware.tests.baz-V1.0-java \
-    android.hidl.base-V1.0-java \
-
-
-#
-# Build types.hal (Bar)
-#
-GEN := $(intermediates)/tests/vendor/V1_0/Bar.java
-$(GEN): $(HIDL)
-$(GEN): PRIVATE_HIDL := $(HIDL)
-$(GEN): PRIVATE_DEPS := $(LOCAL_PATH)/types.hal
-$(GEN): PRIVATE_OUTPUT_DIR := $(intermediates)
-$(GEN): PRIVATE_CUSTOM_TOOL = \
-        $(PRIVATE_HIDL) -o $(PRIVATE_OUTPUT_DIR) \
-        -Ljava \
-        -randroid.hardware:hardware/interfaces \
-        -randroid.hidl:system/libhidl/transport \
-        -rtests:system/tools/hidl/test/ \
-        tests.vendor@1.0::types.Bar
-
-$(GEN): $(LOCAL_PATH)/types.hal
-	$(transform-generated-source)
-LOCAL_GENERATED_SOURCES += $(GEN)
-
-#
-# Build types.hal (Foo)
-#
-GEN := $(intermediates)/tests/vendor/V1_0/Foo.java
-$(GEN): $(HIDL)
-$(GEN): PRIVATE_HIDL := $(HIDL)
-$(GEN): PRIVATE_DEPS := $(LOCAL_PATH)/types.hal
-$(GEN): PRIVATE_OUTPUT_DIR := $(intermediates)
-$(GEN): PRIVATE_CUSTOM_TOOL = \
-        $(PRIVATE_HIDL) -o $(PRIVATE_OUTPUT_DIR) \
-        -Ljava \
-        -randroid.hardware:hardware/interfaces \
-        -randroid.hidl:system/libhidl/transport \
-        -rtests:system/tools/hidl/test/ \
-        tests.vendor@1.0::types.Foo
-
-$(GEN): $(LOCAL_PATH)/types.hal
-	$(transform-generated-source)
-LOCAL_GENERATED_SOURCES += $(GEN)
-
-#
-# Build types.hal (FooToo)
-#
-GEN := $(intermediates)/tests/vendor/V1_0/FooToo.java
-$(GEN): $(HIDL)
-$(GEN): PRIVATE_HIDL := $(HIDL)
-$(GEN): PRIVATE_DEPS := $(LOCAL_PATH)/types.hal
-$(GEN): PRIVATE_OUTPUT_DIR := $(intermediates)
-$(GEN): PRIVATE_CUSTOM_TOOL = \
-        $(PRIVATE_HIDL) -o $(PRIVATE_OUTPUT_DIR) \
-        -Ljava \
-        -randroid.hardware:hardware/interfaces \
-        -randroid.hidl:system/libhidl/transport \
-        -rtests:system/tools/hidl/test/ \
-        tests.vendor@1.0::types.FooToo
-
-$(GEN): $(LOCAL_PATH)/types.hal
-	$(transform-generated-source)
-LOCAL_GENERATED_SOURCES += $(GEN)
-
-#
-# Build IVendor.hal
-#
-GEN := $(intermediates)/tests/vendor/V1_0/IVendor.java
-$(GEN): $(HIDL)
-$(GEN): PRIVATE_HIDL := $(HIDL)
-$(GEN): PRIVATE_DEPS := $(LOCAL_PATH)/IVendor.hal
-$(GEN): PRIVATE_OUTPUT_DIR := $(intermediates)
-$(GEN): PRIVATE_CUSTOM_TOOL = \
-        $(PRIVATE_HIDL) -o $(PRIVATE_OUTPUT_DIR) \
-        -Ljava \
-        -randroid.hardware:hardware/interfaces \
-        -randroid.hidl:system/libhidl/transport \
-        -rtests:system/tools/hidl/test/ \
-        tests.vendor@1.0::IVendor
-
-$(GEN): $(LOCAL_PATH)/IVendor.hal
-	$(transform-generated-source)
-LOCAL_GENERATED_SOURCES += $(GEN)
-include $(BUILD_JAVA_LIBRARY)
-
-
-################################################################################
-
-include $(CLEAR_VARS)
-LOCAL_MODULE := tests.vendor-V1.0-java-static
-LOCAL_MODULE_CLASS := JAVA_LIBRARIES
-
-intermediates := $(call local-generated-sources-dir, COMMON)
-
-HIDL := $(HOST_OUT_EXECUTABLES)/hidl-gen$(HOST_EXECUTABLE_SUFFIX)
-
-LOCAL_STATIC_JAVA_LIBRARIES := \
-    android.hardware.tests.baz-V1.0-java-static \
-    android.hidl.base-V1.0-java-static \
-
-
-#
-# Build types.hal (Bar)
-#
-GEN := $(intermediates)/tests/vendor/V1_0/Bar.java
-$(GEN): $(HIDL)
-$(GEN): PRIVATE_HIDL := $(HIDL)
-$(GEN): PRIVATE_DEPS := $(LOCAL_PATH)/types.hal
-$(GEN): PRIVATE_OUTPUT_DIR := $(intermediates)
-$(GEN): PRIVATE_CUSTOM_TOOL = \
-        $(PRIVATE_HIDL) -o $(PRIVATE_OUTPUT_DIR) \
-        -Ljava \
-        -randroid.hardware:hardware/interfaces \
-        -randroid.hidl:system/libhidl/transport \
-        -rtests:system/tools/hidl/test/ \
-        tests.vendor@1.0::types.Bar
-
-$(GEN): $(LOCAL_PATH)/types.hal
-	$(transform-generated-source)
-LOCAL_GENERATED_SOURCES += $(GEN)
-
-#
-# Build types.hal (Foo)
-#
-GEN := $(intermediates)/tests/vendor/V1_0/Foo.java
-$(GEN): $(HIDL)
-$(GEN): PRIVATE_HIDL := $(HIDL)
-$(GEN): PRIVATE_DEPS := $(LOCAL_PATH)/types.hal
-$(GEN): PRIVATE_OUTPUT_DIR := $(intermediates)
-$(GEN): PRIVATE_CUSTOM_TOOL = \
-        $(PRIVATE_HIDL) -o $(PRIVATE_OUTPUT_DIR) \
-        -Ljava \
-        -randroid.hardware:hardware/interfaces \
-        -randroid.hidl:system/libhidl/transport \
-        -rtests:system/tools/hidl/test/ \
-        tests.vendor@1.0::types.Foo
-
-$(GEN): $(LOCAL_PATH)/types.hal
-	$(transform-generated-source)
-LOCAL_GENERATED_SOURCES += $(GEN)
-
-#
-# Build types.hal (FooToo)
-#
-GEN := $(intermediates)/tests/vendor/V1_0/FooToo.java
-$(GEN): $(HIDL)
-$(GEN): PRIVATE_HIDL := $(HIDL)
-$(GEN): PRIVATE_DEPS := $(LOCAL_PATH)/types.hal
-$(GEN): PRIVATE_OUTPUT_DIR := $(intermediates)
-$(GEN): PRIVATE_CUSTOM_TOOL = \
-        $(PRIVATE_HIDL) -o $(PRIVATE_OUTPUT_DIR) \
-        -Ljava \
-        -randroid.hardware:hardware/interfaces \
-        -randroid.hidl:system/libhidl/transport \
-        -rtests:system/tools/hidl/test/ \
-        tests.vendor@1.0::types.FooToo
-
-$(GEN): $(LOCAL_PATH)/types.hal
-	$(transform-generated-source)
-LOCAL_GENERATED_SOURCES += $(GEN)
-
-#
-# Build IVendor.hal
-#
-GEN := $(intermediates)/tests/vendor/V1_0/IVendor.java
-$(GEN): $(HIDL)
-$(GEN): PRIVATE_HIDL := $(HIDL)
-$(GEN): PRIVATE_DEPS := $(LOCAL_PATH)/IVendor.hal
-$(GEN): PRIVATE_OUTPUT_DIR := $(intermediates)
-$(GEN): PRIVATE_CUSTOM_TOOL = \
-        $(PRIVATE_HIDL) -o $(PRIVATE_OUTPUT_DIR) \
-        -Ljava \
-        -randroid.hardware:hardware/interfaces \
-        -randroid.hidl:system/libhidl/transport \
-        -rtests:system/tools/hidl/test/ \
-        tests.vendor@1.0::IVendor
-
-$(GEN): $(LOCAL_PATH)/IVendor.hal
-	$(transform-generated-source)
-LOCAL_GENERATED_SOURCES += $(GEN)
-include $(BUILD_STATIC_JAVA_LIBRARY)
-
-
-################################################################################
-
-include $(CLEAR_VARS)
-LOCAL_MODULE := tests.vendor-V1.0-java-constants
-LOCAL_MODULE_CLASS := JAVA_LIBRARIES
-
-intermediates := $(call local-generated-sources-dir, COMMON)
-
-HIDL := $(HOST_OUT_EXECUTABLES)/hidl-gen$(HOST_EXECUTABLE_SUFFIX)
-#
-GEN := $(intermediates)/tests/vendor/V1_0/Constants.java
-$(GEN): $(HIDL)
-$(GEN): $(LOCAL_PATH)/types.hal
-$(GEN): $(LOCAL_PATH)/IVendor.hal
-
-$(GEN): PRIVATE_HIDL := $(HIDL)
-$(GEN): PRIVATE_OUTPUT_DIR := $(intermediates)
-$(GEN): PRIVATE_CUSTOM_TOOL = \
-        $(PRIVATE_HIDL) -o $(PRIVATE_OUTPUT_DIR) \
-        -Ljava-constants \
-        -randroid.hardware:hardware/interfaces \
-        -randroid.hidl:system/libhidl/transport \
-        -rtests:system/tools/hidl/test/ \
-        tests.vendor@1.0
-
-$(GEN):
-	$(transform-generated-source)
-LOCAL_GENERATED_SOURCES += $(GEN)
-# Avoid dependency cycle of framework.jar -> this-library -> framework.jar
-LOCAL_NO_STANDARD_LIBRARIES := true
-LOCAL_JAVA_LIBRARIES := core-oj
-
-include $(BUILD_STATIC_JAVA_LIBRARY)
-
-
-
-include $(call all-makefiles-under,$(LOCAL_PATH))
diff --git a/test/vendor/1.0/IVendor.hal b/test/vendor/1.0/IVendor.hal
index 3beebea..c963d3f 100644
--- a/test/vendor/1.0/IVendor.hal
+++ b/test/vendor/1.0/IVendor.hal
@@ -1,37 +1,39 @@
-/*
- * Copyright (C) 2016 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.
- */
-
-package tests.vendor@1.0;
-
-import android.hardware.tests.baz@1.0;
-
-interface IVendor extends IBaz {
-
-    struct StructTest {
-        vec<uint8_t> b;
-        string d;
-        uint8_t[4][4] e;
-    };
-
-    fun2(vec<uint8_t> a) generates(vec<uint8_t> b);
-    fun4(string a) generates(string b);
-    fun5(uint8_t[4][4] a) generates(uint8_t[4][4] b);
-
-    // Testing static functions in derived class
-    // overriding virtual functions in parent class
-    // due to namespace resolution.
-    registerForNotifications();
-};
\ No newline at end of file
+// note this file tests carriage returns
+
+/*
+ * Copyright (C) 2016 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.
+ */
+
+package hidl.tests.vendor@1.0;
+
+import android.hardware.tests.baz@1.0;
+
+interface IVendor extends IBaz {
+
+    struct StructTest {
+        vec<uint8_t> b;
+        string d;
+        uint8_t[4][4] e;
+    };
+
+    fun2(vec<uint8_t> a) generates(vec<uint8_t> b);
+    fun4(string a) generates(string b);
+    fun5(uint8_t[4][4] a) generates(uint8_t[4][4] b);
+
+    // Testing static functions in derived class
+    // overriding virtual functions in parent class
+    // due to namespace resolution.
+    registerForNotifications();
+};
diff --git a/test/vendor/1.0/types.hal b/test/vendor/1.0/types.hal
index 511389e..4763f0e 100644
--- a/test/vendor/1.0/types.hal
+++ b/test/vendor/1.0/types.hal
@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 
-package tests.vendor@1.0;
+package hidl.tests.vendor@1.0;
 
 enum Bar : uint32_t {
     A
diff --git a/test/vendor/1.0/update-base.sh b/test/vendor/1.0/update-base.sh
index 7940328..933480f 100755
--- a/test/vendor/1.0/update-base.sh
+++ b/test/vendor/1.0/update-base.sh
@@ -4,7 +4,7 @@
 # It should typically be created elsewhere.
 
 options="-Lexport-header \
-         -r tests:system/tools/hidl/test/\
+         -r hidl.tests:system/tools/hidl/test/\
          -r android.hidl:system/libhidl/transport\
          -r android.hardware:hardware/interfaces"
 
diff --git a/test/vendor/1.1/Android.bp b/test/vendor/1.1/Android.bp
index 6d41300..80cecb2 100644
--- a/test/vendor/1.1/Android.bp
+++ b/test/vendor/1.1/Android.bp
@@ -1,90 +1,18 @@
-// This file is autogenerated by hidl-gen. Do not edit manually.
+// This file is autogenerated by hidl-gen -Landroidbp.
 
-filegroup {
-    name: "tests.vendor@1.1_hal",
+hidl_interface {
+    name: "hidl.tests.vendor@1.1",
+    owner: "some-owner-name",
+    root: "hidl.tests",
     srcs: [
         "IVendor.hal",
     ],
+    interfaces: [
+        "android.frameworks.displayservice@1.0",
+        "android.hardware.tests.baz@1.0",
+        "android.hidl.base@1.0",
+        "hidl.tests.vendor@1.0",
+    ],
+    gen_java: true,
 }
 
-genrule {
-    name: "tests.vendor@1.1_genc++",
-    tools: ["hidl-gen"],
-    cmd: "$(location hidl-gen) -o $(genDir) -Lc++-sources -randroid.hardware:hardware/interfaces -randroid.hidl:system/libhidl/transport -rtests:system/tools/hidl/test/ tests.vendor@1.1",
-    srcs: [
-        ":tests.vendor@1.1_hal",
-    ],
-    out: [
-        "tests/vendor/1.1/VendorAll.cpp",
-    ],
-}
-
-genrule {
-    name: "tests.vendor@1.1_genc++_headers",
-    tools: ["hidl-gen"],
-    cmd: "$(location hidl-gen) -o $(genDir) -Lc++-headers -randroid.hardware:hardware/interfaces -randroid.hidl:system/libhidl/transport -rtests:system/tools/hidl/test/ tests.vendor@1.1",
-    srcs: [
-        ":tests.vendor@1.1_hal",
-    ],
-    out: [
-        "tests/vendor/1.1/IVendor.h",
-        "tests/vendor/1.1/IHwVendor.h",
-        "tests/vendor/1.1/BnHwVendor.h",
-        "tests/vendor/1.1/BpHwVendor.h",
-        "tests/vendor/1.1/BsVendor.h",
-    ],
-}
-
-cc_library {
-    name: "tests.vendor@1.1",
-    defaults: ["hidl-module-defaults"],
-    generated_sources: ["tests.vendor@1.1_genc++"],
-    generated_headers: ["tests.vendor@1.1_genc++_headers"],
-    export_generated_headers: ["tests.vendor@1.1_genc++_headers"],
-    vendor_available: true,
-    shared_libs: [
-        "libhidlbase",
-        "libhidltransport",
-        "libhwbinder",
-        "liblog",
-        "libutils",
-        "libcutils",
-        "android.hardware.tests.baz@1.0",
-        "tests.vendor@1.0",
-    ],
-    export_shared_lib_headers: [
-        "libhidlbase",
-        "libhidltransport",
-        "libhwbinder",
-        "libutils",
-        "android.hardware.tests.baz@1.0",
-        "tests.vendor@1.0",
-    ],
-}
-
-cc_library {
-    name: "tests.vendor@1.1_vendor",
-    defaults: ["hidl-module-defaults"],
-    generated_sources: ["tests.vendor@1.1_genc++"],
-    generated_headers: ["tests.vendor@1.1_genc++_headers"],
-    export_generated_headers: ["tests.vendor@1.1_genc++_headers"],
-    vendor: true,
-    shared_libs: [
-        "libhidlbase",
-        "libhidltransport",
-        "libhwbinder",
-        "liblog",
-        "libutils",
-        "libcutils",
-        "android.hardware.tests.baz@1.0",
-        "tests.vendor@1.0_vendor",
-    ],
-    export_shared_lib_headers: [
-        "libhidlbase",
-        "libhidltransport",
-        "libhwbinder",
-        "libutils",
-        "android.hardware.tests.baz@1.0",
-        "tests.vendor@1.0_vendor",
-    ],
-}
diff --git a/test/vendor/1.1/Android.mk b/test/vendor/1.1/Android.mk
deleted file mode 100644
index 4427516..0000000
--- a/test/vendor/1.1/Android.mk
+++ /dev/null
@@ -1,82 +0,0 @@
-# This file is autogenerated by hidl-gen. Do not edit manually.
-
-LOCAL_PATH := $(call my-dir)
-
-################################################################################
-
-include $(CLEAR_VARS)
-LOCAL_MODULE := tests.vendor-V1.1-java
-LOCAL_MODULE_CLASS := JAVA_LIBRARIES
-
-intermediates := $(call local-generated-sources-dir, COMMON)
-
-HIDL := $(HOST_OUT_EXECUTABLES)/hidl-gen$(HOST_EXECUTABLE_SUFFIX)
-
-LOCAL_JAVA_LIBRARIES := \
-    android.hardware.tests.baz-V1.0-java \
-    android.hidl.base-V1.0-java \
-    tests.vendor-V1.0-java \
-
-
-#
-# Build IVendor.hal
-#
-GEN := $(intermediates)/tests/vendor/V1_1/IVendor.java
-$(GEN): $(HIDL)
-$(GEN): PRIVATE_HIDL := $(HIDL)
-$(GEN): PRIVATE_DEPS := $(LOCAL_PATH)/IVendor.hal
-$(GEN): PRIVATE_OUTPUT_DIR := $(intermediates)
-$(GEN): PRIVATE_CUSTOM_TOOL = \
-        $(PRIVATE_HIDL) -o $(PRIVATE_OUTPUT_DIR) \
-        -Ljava \
-        -randroid.hardware:hardware/interfaces \
-        -randroid.hidl:system/libhidl/transport \
-        -rtests:system/tools/hidl/test/ \
-        tests.vendor@1.1::IVendor
-
-$(GEN): $(LOCAL_PATH)/IVendor.hal
-	$(transform-generated-source)
-LOCAL_GENERATED_SOURCES += $(GEN)
-include $(BUILD_JAVA_LIBRARY)
-
-
-################################################################################
-
-include $(CLEAR_VARS)
-LOCAL_MODULE := tests.vendor-V1.1-java-static
-LOCAL_MODULE_CLASS := JAVA_LIBRARIES
-
-intermediates := $(call local-generated-sources-dir, COMMON)
-
-HIDL := $(HOST_OUT_EXECUTABLES)/hidl-gen$(HOST_EXECUTABLE_SUFFIX)
-
-LOCAL_STATIC_JAVA_LIBRARIES := \
-    android.hardware.tests.baz-V1.0-java-static \
-    android.hidl.base-V1.0-java-static \
-    tests.vendor-V1.0-java-static \
-
-
-#
-# Build IVendor.hal
-#
-GEN := $(intermediates)/tests/vendor/V1_1/IVendor.java
-$(GEN): $(HIDL)
-$(GEN): PRIVATE_HIDL := $(HIDL)
-$(GEN): PRIVATE_DEPS := $(LOCAL_PATH)/IVendor.hal
-$(GEN): PRIVATE_OUTPUT_DIR := $(intermediates)
-$(GEN): PRIVATE_CUSTOM_TOOL = \
-        $(PRIVATE_HIDL) -o $(PRIVATE_OUTPUT_DIR) \
-        -Ljava \
-        -randroid.hardware:hardware/interfaces \
-        -randroid.hidl:system/libhidl/transport \
-        -rtests:system/tools/hidl/test/ \
-        tests.vendor@1.1::IVendor
-
-$(GEN): $(LOCAL_PATH)/IVendor.hal
-	$(transform-generated-source)
-LOCAL_GENERATED_SOURCES += $(GEN)
-include $(BUILD_STATIC_JAVA_LIBRARY)
-
-
-
-include $(call all-makefiles-under,$(LOCAL_PATH))
diff --git a/test/vendor/1.1/IVendor.hal b/test/vendor/1.1/IVendor.hal
index 4821048..437d79f 100644
--- a/test/vendor/1.1/IVendor.hal
+++ b/test/vendor/1.1/IVendor.hal
@@ -14,10 +14,14 @@
  * limitations under the License.
  */
 
-package tests.vendor@1.1;
+package hidl.tests.vendor@1.1;
 
-import tests.vendor@1.0::IVendor;
+import hidl.tests.vendor@1.0::IVendor;
 
-interface IVendor extends IVendor {
+// this import is unused, but it should still show up in the
+// associated Android.bp
+import android.frameworks.displayservice@1.0;
+
+interface IVendor extends @1.0::IVendor {
     doAdditionalFunctionality();
 };
diff --git a/test/vendor/Android.bp b/test/vendor/Android.bp
new file mode 100644
index 0000000..dfcd349
--- /dev/null
+++ b/test/vendor/Android.bp
@@ -0,0 +1,4 @@
+hidl_package_root {
+    name: "hidl.tests",
+    path: "system/tools/hidl/test",
+}
diff --git a/test/vendor/Android.mk b/test/vendor/Android.mk
deleted file mode 100644
index 3bda3b9..0000000
--- a/test/vendor/Android.mk
+++ /dev/null
@@ -1,16 +0,0 @@
-# Copyright (C) 2017 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.
-LOCAL_PATH:= $(call my-dir)
-
-include $(call all-makefiles-under,$(LOCAL_PATH))
\ No newline at end of file
diff --git a/test/vendor/update-makefile.sh b/test/vendor/update-makefile.sh
index 87e7340..49ced20 100755
--- a/test/vendor/update-makefile.sh
+++ b/test/vendor/update-makefile.sh
@@ -1,10 +1,9 @@
 #!/bin/bash
 
-options="-r tests:system/tools/hidl/test/ \
-         -r android.hidl:system/libhidl/transport \
+options="-O some-owner-name
+         -r hidl.tests:system/tools/hidl/test/
+         -r android.hidl:system/libhidl/transport
          -r android.hardware:hardware/interfaces"
 
-hidl-gen -Lmakefile $options tests.vendor@1.0;
-hidl-gen -Landroidbp $options -t tests.vendor@1.0;
-hidl-gen -Lmakefile $options tests.vendor@1.1;
-hidl-gen -Landroidbp $options -t tests.vendor@1.1;
+hidl-gen -Landroidbp $options hidl.tests.vendor@1.0;
+hidl-gen -Landroidbp $options hidl.tests.vendor@1.1;
diff --git a/test/version_test/Android.bp b/test/version_test/Android.bp
index 696f501..3629b8a 100644
--- a/test/version_test/Android.bp
+++ b/test/version_test/Android.bp
@@ -10,6 +10,8 @@
          "    test.version.version@2.3" +
          "    test.version.version@2.4" +
          "    test.version.version@2.5" +
+         "    test.version.version@3.0" +
+         "    test.version.version@3.1" +
          "&&" +
          "($(location hidl-gen) -L check " +
          "    -r test.version:system/tools/hidl/test/version_test/bad1" +
@@ -27,6 +29,10 @@
          "    -r test.version:system/tools/hidl/test/version_test/bad4" +
          "    test.version.version@2.3 2>&1 | grep \"doesn't pass minor version\" > /dev/null)" +
          "&&" +
+         "($(location hidl-gen) -L check " +
+         "    -r test.version:system/tools/hidl/test/version_test/bad5" +
+         "    test.version.version@2.3 2>&1 | grep \"doesn't pass minor version\" > /dev/null)" +
+         "&&" +
          "echo 'int main(){return 0;}' > $(genDir)/TODO_b_37575883.cpp",
     out: ["TODO_b_37575883.cpp"],
 
@@ -48,6 +54,8 @@
         "bad4/version/2.2/IBar.hal",
         "bad4/version/2.2/IFoo.hal",
         "bad4/version/2.3/IBaz.hal",
+        "bad5/version/2.2/IFoo.hal",
+        "bad5/version/2.3/IBaz.hal",
         "good/version/1.0/IFoo.hal",
         "good/version/2.2/IBar.hal",
         "good/version/2.2/IFoo.hal",
@@ -57,10 +65,14 @@
         "good/version/2.4/IFoo.hal",
         "good/version/2.5/IBar.hal",
         "good/version/2.5/IFoo.hal",
+        "good/version/3.0/types.hal",
+        "good/version/3.1/ICanExtendTypesOnly.hal",
+        "good/version/3.1/types.hal",
     ]
 }
 
 cc_test_host {
     name: "hidl_version_test",
+    cflags: ["-Wall", "-Werror"],
     generated_sources: ["hidl_hash_version_gen"],
-}
\ No newline at end of file
+}
diff --git a/test/error_test/no_interface_in_types/error/1.0/IFoo.hal b/test/version_test/bad5/version/2.2/IFoo.hal
similarity index 86%
copy from test/error_test/no_interface_in_types/error/1.0/IFoo.hal
copy to test/version_test/bad5/version/2.2/IFoo.hal
index d79e6ab..a672f76 100644
--- a/test/error_test/no_interface_in_types/error/1.0/IFoo.hal
+++ b/test/version_test/bad5/version/2.2/IFoo.hal
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2017 The Android Open Source Project
+ * Copyright (C) 2016 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.
@@ -13,7 +13,9 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-package test.error.error@1.0;
+
+package test.version.version@2.2;
 
 interface IFoo {
-};
\ No newline at end of file
+
+};
diff --git a/test/error_test/no_interface_in_types/error/1.0/IFoo.hal b/test/version_test/bad5/version/2.3/IBaz.hal
similarity index 83%
copy from test/error_test/no_interface_in_types/error/1.0/IFoo.hal
copy to test/version_test/bad5/version/2.3/IBaz.hal
index d79e6ab..8e71cd2 100644
--- a/test/error_test/no_interface_in_types/error/1.0/IFoo.hal
+++ b/test/version_test/bad5/version/2.3/IBaz.hal
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2017 The Android Open Source Project
+ * Copyright (C) 2016 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.
@@ -13,7 +13,9 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-package test.error.error@1.0;
 
-interface IFoo {
-};
\ No newline at end of file
+package test.version.version@2.3;
+
+interface IBaz {
+
+};
diff --git a/test/error_test/no_interface_in_types/error/1.0/IFoo.hal b/test/version_test/good/version/3.0/types.hal
similarity index 90%
copy from test/error_test/no_interface_in_types/error/1.0/IFoo.hal
copy to test/version_test/good/version/3.0/types.hal
index d79e6ab..27db609 100644
--- a/test/error_test/no_interface_in_types/error/1.0/IFoo.hal
+++ b/test/version_test/good/version/3.0/types.hal
@@ -13,7 +13,9 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-package test.error.error@1.0;
 
-interface IFoo {
-};
\ No newline at end of file
+package test.version.version@3.0;
+
+enum A : uint32_t {
+    B
+};
diff --git a/test/error_test/no_interface_in_types/error/1.0/IFoo.hal b/test/version_test/good/version/3.1/ICanExtendTypesOnly.hal
similarity index 81%
copy from test/error_test/no_interface_in_types/error/1.0/IFoo.hal
copy to test/version_test/good/version/3.1/ICanExtendTypesOnly.hal
index d79e6ab..cbbfa8e 100644
--- a/test/error_test/no_interface_in_types/error/1.0/IFoo.hal
+++ b/test/version_test/good/version/3.1/ICanExtendTypesOnly.hal
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2017 The Android Open Source Project
+ * Copyright (C) 2016 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.
@@ -13,7 +13,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-package test.error.error@1.0;
 
-interface IFoo {
-};
\ No newline at end of file
+package test.version.version@3.1;
+
+interface ICanExtendTypesOnly {};
diff --git a/test/error_test/no_interface_in_types/error/1.0/IFoo.hal b/test/version_test/good/version/3.1/types.hal
similarity index 88%
copy from test/error_test/no_interface_in_types/error/1.0/IFoo.hal
copy to test/version_test/good/version/3.1/types.hal
index d79e6ab..bc9964d 100644
--- a/test/error_test/no_interface_in_types/error/1.0/IFoo.hal
+++ b/test/version_test/good/version/3.1/types.hal
@@ -13,7 +13,11 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-package test.error.error@1.0;
 
-interface IFoo {
-};
\ No newline at end of file
+package test.version.version@3.1;
+
+import @3.0::A;
+
+enum A : @3.0::A {
+    C
+};
diff --git a/update-all-google-makefiles.sh b/update-all-google-makefiles.sh
index 7491ac6..178137d 100755
--- a/update-all-google-makefiles.sh
+++ b/update-all-google-makefiles.sh
@@ -7,4 +7,4 @@
 $ANDROID_BUILD_TOP/frameworks/hardware/interfaces/update-makefiles.sh
 $ANDROID_BUILD_TOP/system/hardware/interfaces/update-makefiles.sh
 
-$ANDROID_BUILD_TOP/system/tools/hidl/test/vendor/1.0/update-makefile.sh
+$ANDROID_BUILD_TOP/system/tools/hidl/test/vendor/update-makefile.sh
diff --git a/update-makefiles-helper.sh b/update-makefiles-helper.sh
index 904c4ed..30f38a6 100755
--- a/update-makefiles-helper.sh
+++ b/update-makefiles-helper.sh
@@ -52,19 +52,6 @@
 }
 
 ##
-# Subdirectories of a directory which contain Android.bps
-# Note, does not return Android.bp in the current directory.
-#
-# Usage: get_bp_dirs dir
-function get_bp_dirs() {
-  find $1/*                          \
-    -mindepth 1                      \
-    -name "Android.bp"               \
-    -printf "%H\n"                   \
-    | sort | uniq
-}
-
-##
 # Returns directory path for a package
 # Usage: get_package_dir package_root_dir package_prefix package
 function get_package_dir() {
@@ -77,10 +64,16 @@
 # Helps manage the package root of a HAL directory.
 # Should be called from the android root directory.
 #
-# Usage: do_makefiles_update [package:root ...]
+# Usage: do_makefiles_update [-O owner-name] [package:root ...]
 # Where the first package root is the current one.
 #
 function do_makefiles_update() {
+  local owner=
+  if [[ "$1" = "-O" ]]; then
+      owner="$2"
+      shift 2
+  fi
+
   local root_or_cwd=${ANDROID_BUILD_TOP%%/}${ANDROID_BUILD_TOP:+/}
 
   local current_package=$(package_root_to_package $1)
@@ -95,32 +88,7 @@
 
   for p in $packages; do
     echo "Updating $p";
-    local additional_options=
-    if [[ -f $(get_package_dir $current_dir $current_package $p)/.hidl_for_test ]]; then additional_options="-t"; fi
-    hidl-gen -Lmakefile $root_arguments $p;
+    hidl-gen -O "$owner" -Landroidbp $root_arguments $p;
     rc=$?; if [[ $rc != 0 ]]; then return $rc; fi
-    hidl-gen -Landroidbp $root_arguments $additional_options $p;
-    rc=$?; if [[ $rc != 0 ]]; then return $rc; fi
-  done
-
-  local android_dirs=$(get_bp_dirs $current_dir) || return 1
-
-  echo "Updating Android.bp files."
-
-  for bp_dir in $android_dirs; do
-    bp="$bp_dir/Android.bp"
-    # locations of Android.bp files in specific subdirectory of frameworks/hardware/interfaces
-    android_bps=$(find $bp_dir                   \
-                  -name "Android.bp"             \
-                  ! -path $bp_dir/Android.bp     \
-                  -printf "%h\n"                 \
-                  | sort)
-
-    echo "// This is an autogenerated file, do not edit." > "$bp";
-    echo "subdirs = [" >> "$bp";
-    for a in $android_bps; do
-      echo "    \"${a#$bp_dir/}\"," >> "$bp";
-    done
-    echo "]" >> "$bp";
   done
 }
diff --git a/utils/Android.bp b/utils/Android.bp
index ff171d3..7d97c75 100644
--- a/utils/Android.bp
+++ b/utils/Android.bp
@@ -15,16 +15,15 @@
 cc_library {
     name: "libhidl-gen-utils",
     host_supported: true,
-    vendor_available: true,
-    cflags: hidl_flags,
+    defaults: ["hidl-gen-defaults"],
     srcs: [
         "FQName.cpp",
         "Formatter.cpp",
+        "FqInstance.cpp",
         "StringHelper.cpp",
     ],
     shared_libs: [
         "libbase",
-        "liblog",
     ],
 
     local_include_dirs: ["include/hidl-util"],
diff --git a/utils/FQName.cpp b/utils/FQName.cpp
index 630fff4..8f56af8 100644
--- a/utils/FQName.cpp
+++ b/utils/FQName.cpp
@@ -29,27 +29,6 @@
 #define RE_MAJOR        "[0-9]+"
 #define RE_MINOR        "[0-9]+"
 
-// android.hardware.foo@1.0::IFoo.Type
-static const std::regex kRE1("(" RE_PATH ")@(" RE_MAJOR ")[.](" RE_MINOR ")::(" RE_PATH ")");
-// @1.0::IFoo.Type
-static const std::regex kRE2("@(" RE_MAJOR ")[.](" RE_MINOR ")::(" RE_PATH ")");
-// android.hardware.foo@1.0 (for package declaration and whole package import)
-static const std::regex kRE3("(" RE_PATH ")@(" RE_MAJOR ")[.](" RE_MINOR ")");
-// IFoo.Type
-static const std::regex kRE4("(" RE_COMPONENT ")([.]" RE_COMPONENT ")+");
-// Type (a plain identifier)
-static const std::regex kRE5("(" RE_COMPONENT ")");
-
-// android.hardware.foo@1.0::IFoo.Type:MY_ENUM_VALUE
-static const std::regex kRE6("(" RE_PATH ")@(" RE_MAJOR ")[.](" RE_MINOR ")::(" RE_PATH "):(" RE_COMPONENT ")");
-// @1.0::IFoo.Type:MY_ENUM_VALUE
-static const std::regex kRE7("@(" RE_MAJOR ")[.](" RE_MINOR ")::(" RE_PATH "):(" RE_COMPONENT ")");
-// IFoo.Type:MY_ENUM_VALUE
-static const std::regex kRE8("(" RE_PATH "):(" RE_COMPONENT ")");
-
-// 1.0
-static const std::regex kREVer("(" RE_MAJOR ")[.](" RE_MINOR ")");
-
 namespace android {
 
 FQName::FQName()
@@ -57,10 +36,15 @@
       mIsIdentifier(false) {
 }
 
+// TODO(b/73774955): delete
 FQName::FQName(const std::string &s)
     : mValid(false),
       mIsIdentifier(false) {
-    setTo(s);
+    (void)setTo(s);
+}
+
+bool FQName::parse(const std::string& s, FQName* into) {
+    return into->setTo(s);
 }
 
 FQName::FQName(
@@ -73,12 +57,12 @@
       mPackage(package),
       mName(name),
       mValueName(valueName) {
-    setVersion(version);
+    CHECK(setVersion(version)) << version;
 
     // Check if this is actually a valid fqName
     FQName other;
-    other.setTo(this->string());
-    CHECK(other.mValid && (*this) == other);
+    CHECK(parse(this->string(), &other)) << this->string();
+    CHECK((*this) == other) << this->string() << " " << other.string();
 }
 
 FQName::FQName(const FQName& other)
@@ -91,12 +75,6 @@
       mValueName(other.mValueName) {
 }
 
-FQName::FQName(const std::vector<std::string> &names)
-    : mValid(false),
-      mIsIdentifier(false) {
-    setTo(StringHelper::JoinStrings(names, "."));
-}
-
 bool FQName::isValid() const {
     return mValid;
 }
@@ -114,30 +92,51 @@
         || (!mName.empty() && !mValueName.empty());
 }
 
-bool FQName::setTo(const std::string &s) {
-    clearVersion();
-    mPackage.clear();
-    mName.clear();
+bool FQName::isInterfaceName() const {
+    return !mName.empty() && mName[0] == 'I' && mName.find('.') == std::string::npos;
+}
 
-    mValid = true;
+bool FQName::setTo(const std::string &s) {
+    // android.hardware.foo@1.0::IFoo.Type
+    static const std::regex kRE1("(" RE_PATH ")@(" RE_MAJOR ")[.](" RE_MINOR ")::(" RE_PATH ")");
+    // @1.0::IFoo.Type
+    static const std::regex kRE2("@(" RE_MAJOR ")[.](" RE_MINOR ")::(" RE_PATH ")");
+    // android.hardware.foo@1.0 (for package declaration and whole package import)
+    static const std::regex kRE3("(" RE_PATH ")@(" RE_MAJOR ")[.](" RE_MINOR ")");
+    // IFoo.Type
+    static const std::regex kRE4("(" RE_COMPONENT ")([.]" RE_COMPONENT ")+");
+    // Type (a plain identifier)
+    static const std::regex kRE5("(" RE_COMPONENT ")");
+
+    // android.hardware.foo@1.0::IFoo.Type:MY_ENUM_VALUE
+    static const std::regex kRE6("(" RE_PATH ")@(" RE_MAJOR ")[.](" RE_MINOR ")::(" RE_PATH
+                                 "):(" RE_COMPONENT ")");
+    // @1.0::IFoo.Type:MY_ENUM_VALUE
+    static const std::regex kRE7("@(" RE_MAJOR ")[.](" RE_MINOR ")::(" RE_PATH "):(" RE_COMPONENT
+                                 ")");
+    // IFoo.Type:MY_ENUM_VALUE
+    static const std::regex kRE8("(" RE_PATH "):(" RE_COMPONENT ")");
+
+    bool invalid = false;
+    clear();
 
     std::smatch match;
     if (std::regex_match(s, match, kRE1)) {
         CHECK_EQ(match.size(), 5u);
 
         mPackage = match.str(1);
-        parseVersion(match.str(2), match.str(3));
+        invalid |= !parseVersion(match.str(2), match.str(3));
         mName = match.str(4);
     } else if (std::regex_match(s, match, kRE2)) {
         CHECK_EQ(match.size(), 4u);
 
-        parseVersion(match.str(1), match.str(2));
+        invalid |= !parseVersion(match.str(1), match.str(2));
         mName = match.str(3);
     } else if (std::regex_match(s, match, kRE3)) {
         CHECK_EQ(match.size(), 4u);
 
         mPackage = match.str(1);
-        parseVersion(match.str(2), match.str(3));
+        invalid |= !parseVersion(match.str(2), match.str(3));
     } else if (std::regex_match(s, match, kRE4)) {
         mName = match.str(0);
     } else if (std::regex_match(s, match, kRE5)) {
@@ -147,13 +146,13 @@
         CHECK_EQ(match.size(), 6u);
 
         mPackage = match.str(1);
-        parseVersion(match.str(2), match.str(3));
+        invalid |= !parseVersion(match.str(2), match.str(3));
         mName = match.str(4);
         mValueName = match.str(5);
     } else if (std::regex_match(s, match, kRE7)) {
         CHECK_EQ(match.size(), 5u);
 
-        parseVersion(match.str(1), match.str(2));
+        invalid |= !parseVersion(match.str(1), match.str(2));
         mName = match.str(3);
         mValueName = match.str(4);
     } else if (std::regex_match(s, match, kRE8)) {
@@ -162,19 +161,21 @@
         mName = match.str(1);
         mValueName = match.str(2);
     } else {
-        mValid = false;
+        invalid = true;
     }
 
     // mValueName must go with mName.
     CHECK(mValueName.empty() || !mName.empty());
 
     // package without version is not allowed.
-    CHECK(mPackage.empty() || !version().empty());
+    CHECK(invalid || mPackage.empty() || !version().empty());
 
-    return isValid();
+    // TODO(b/73774955): remove isValid and users
+    // of old FQName constructors
+    return mValid = !invalid;
 }
 
-std::string FQName::package() const {
+const std::string& FQName::package() const {
     return mPackage;
 }
 
@@ -197,26 +198,37 @@
     return v.empty() ? "" : ("@" + v);
 }
 
-void FQName::setVersion(const std::string &v) {
+void FQName::clear() {
+    mValid = true;
+    mIsIdentifier = false;
+    mPackage.clear();
+    clearVersion();
+    mName.clear();
+    mValueName.clear();
+}
+
+bool FQName::setVersion(const std::string& v) {
+    static const std::regex kREVer("(" RE_MAJOR ")[.](" RE_MINOR ")");
+
     if (v.empty()) {
         clearVersion();
-        return;
+        return true;
     }
-    std::smatch match;
-    if (std::regex_match(v, match, kREVer)) {
-        CHECK_EQ(match.size(), 3u);
 
-        parseVersion(match.str(1), match.str(2));
-    } else {
-        mValid = false;
+    std::smatch match;
+    if (!std::regex_match(v, match, kREVer)) {
+        return mValid = false;
     }
+    CHECK_EQ(match.size(), 3u);
+
+    return parseVersion(match.str(1), match.str(2));
 }
 
 void FQName::clearVersion() {
     mMajor = mMinor = 0;
 }
 
-void FQName::parseVersion(const std::string &majorStr, const std::string &minorStr) {
+bool FQName::parseVersion(const std::string& majorStr, const std::string& minorStr) {
     bool versionParseSuccess =
         ::android::base::ParseUint(majorStr, &mMajor) &&
         ::android::base::ParseUint(minorStr, &mMinor);
@@ -224,9 +236,10 @@
         LOG(ERROR) << "numbers in " << majorStr << "." << minorStr << " are out of range.";
         mValid = false;
     }
+    return versionParseSuccess;
 }
 
-std::string FQName::name() const {
+const std::string& FQName::name() const {
     return mName;
 }
 
@@ -240,7 +253,7 @@
     return res;
 }
 
-std::string FQName::valueName() const {
+const std::string& FQName::valueName() const {
     return mValueName;
 }
 
@@ -260,12 +273,12 @@
     }
 
     if (version().empty()) {
-        setVersion(defaultVersion);
+        CHECK(setVersion(defaultVersion));
     }
 }
 
 std::string FQName::string() const {
-    CHECK(mValid);
+    CHECK(mValid) << mPackage << atVersion() << mName;
 
     std::string out;
     out.append(mPackage);
@@ -285,15 +298,6 @@
     return out;
 }
 
-void FQName::print() const {
-    if (!mValid) {
-        LOG(INFO) << "INVALID";
-        return;
-    }
-
-    LOG(INFO) << string();
-}
-
 bool FQName::operator<(const FQName &other) const {
     return string() < other.string();
 }
@@ -306,9 +310,8 @@
     return !(*this == other);
 }
 
-std::string FQName::getInterfaceName() const {
-    CHECK(names().size() == 1) << "Must be a top level type";
-    CHECK(!mName.empty() && mName[0] == 'I') << mName;
+const std::string& FQName::getInterfaceName() const {
+    CHECK(isInterfaceName()) << mName;
 
     return mName;
 }
@@ -318,6 +321,10 @@
     return getInterfaceName().substr(1);
 }
 
+std::string FQName::getInterfaceAdapterName() const {
+    return "A" + getInterfaceBaseName();
+}
+
 std::string FQName::getInterfaceHwName() const {
     return "IHw" + getInterfaceBaseName();
 }
@@ -338,6 +345,10 @@
     return FQName(package(), version(), getInterfaceProxyName());
 }
 
+FQName FQName::getInterfaceAdapterFqName() const {
+    return FQName(package(), version(), getInterfaceAdapterName());
+}
+
 FQName FQName::getInterfaceStubFqName() const {
     return FQName(package(), version(), getInterfaceStubName());
 }
@@ -449,6 +460,13 @@
     return mMajor > 0;
 }
 
+FQName FQName::withVersion(size_t major, size_t minor) const {
+    FQName ret(*this);
+    ret.mMajor = major;
+    ret.mMinor = minor;
+    return ret;
+}
+
 size_t FQName::getPackageMajorVersion() const {
     CHECK(hasVersion()) << "FQName: No version exists at getPackageMajorVersion(). "
                         << "Did you check hasVersion()?";
@@ -524,5 +542,8 @@
     return ret;
 }
 
+const FQName gIBaseFqName = FQName("android.hidl.base", "1.0", "IBase");
+const FQName gIManagerFqName = FQName("android.hidl.manager", "1.0", "IServiceManager");
+
 }  // namespace android
 
diff --git a/utils/Formatter.cpp b/utils/Formatter.cpp
index a4f2047..338cb17 100644
--- a/utils/Formatter.cpp
+++ b/utils/Formatter.cpp
@@ -18,13 +18,17 @@
 
 #include <assert.h>
 
+#include <android-base/logging.h>
+
 namespace android {
 
-Formatter::Formatter(FILE *file)
+Formatter::Formatter() : mFile(NULL /* invalid */), mIndentDepth(0), mAtStartOfLine(true) {}
+
+Formatter::Formatter(FILE* file, size_t spacesPerIndent)
     : mFile(file == NULL ? stdout : file),
       mIndentDepth(0),
-      mAtStartOfLine(true) {
-}
+      mSpacesPerIndent(spacesPerIndent),
+      mAtStartOfLine(true) {}
 
 Formatter::~Formatter() {
     if (mFile != stdout) {
@@ -42,18 +46,18 @@
     mIndentDepth -= level;
 }
 
-Formatter &Formatter::indent(size_t level, std::function<void(void)> func) {
+Formatter& Formatter::indent(size_t level, const std::function<void(void)>& func) {
     this->indent(level);
     func();
     this->unindent(level);
     return *this;
 }
 
-Formatter &Formatter::indent(std::function<void(void)> func) {
+Formatter& Formatter::indent(const std::function<void(void)>& func) {
     return this->indent(1, func);
 }
 
-Formatter &Formatter::block(std::function<void(void)> func) {
+Formatter& Formatter::block(const std::function<void(void)>& func) {
     (*this) << "{\n";
     this->indent(func);
     return (*this) << "}";
@@ -71,42 +75,42 @@
     return (*this) << "\n";
 }
 
-Formatter &Formatter::sIf(const std::string &cond, std::function<void(void)> block) {
+Formatter& Formatter::sIf(const std::string& cond, const std::function<void(void)>& block) {
     (*this) << "if (" << cond << ") ";
     return this->block(block);
 }
 
-Formatter &Formatter::sElseIf(const std::string &cond, std::function<void(void)> block) {
+Formatter& Formatter::sElseIf(const std::string& cond, const std::function<void(void)>& block) {
     (*this) << " else if (" << cond << ") ";
     return this->block(block);
 }
 
-Formatter &Formatter::sElse(std::function<void(void)> block) {
+Formatter& Formatter::sElse(const std::function<void(void)>& block) {
     (*this) << " else ";
     return this->block(block);
 }
 
-Formatter &Formatter::sFor(const std::string &stmts, std::function<void(void)> block) {
+Formatter& Formatter::sFor(const std::string& stmts, const std::function<void(void)>& block) {
     (*this) << "for (" << stmts << ") ";
     return this->block(block);
 }
 
-Formatter &Formatter::sTry(std::function<void(void)> block) {
+Formatter& Formatter::sTry(const std::function<void(void)>& block) {
     (*this) << "try ";
     return this->block(block);
 }
 
-Formatter &Formatter::sCatch(const std::string &exception, std::function<void(void)> block) {
+Formatter& Formatter::sCatch(const std::string& exception, const std::function<void(void)>& block) {
     (*this) << " catch (" << exception << ") ";
     return this->block(block);
 }
 
-Formatter &Formatter::sFinally(std::function<void(void)> block) {
+Formatter& Formatter::sFinally(const std::function<void(void)>& block) {
     (*this) << " finally ";
     return this->block(block);
 }
 
-Formatter &Formatter::sWhile(const std::string &cond, std::function<void(void)> block) {
+Formatter& Formatter::sWhile(const std::string& cond, const std::function<void(void)>& block) {
     (*this) << "while (" << cond << ") ";
     return this->block(block);
 }
@@ -115,12 +119,12 @@
     const size_t len = out.length();
     size_t start = 0;
     while (start < len) {
-        size_t pos = out.find("\n", start);
+        size_t pos = out.find('\n', start);
 
         if (pos == std::string::npos) {
             if (mAtStartOfLine) {
+                fprintf(mFile, "%*s", (int)(mSpacesPerIndent * mIndentDepth), "");
                 fprintf(mFile, "%s", mLinePrefix.c_str());
-                fprintf(mFile, "%*s", (int)(4 * mIndentDepth), "");
                 mAtStartOfLine = false;
             }
 
@@ -128,17 +132,16 @@
             break;
         }
 
+        if (mAtStartOfLine && (pos > start || !mLinePrefix.empty())) {
+            fprintf(mFile, "%*s", (int)(mSpacesPerIndent * mIndentDepth), "");
+            fprintf(mFile, "%s", mLinePrefix.c_str());
+        }
+
         if (pos == start) {
             fprintf(mFile, "\n");
             mAtStartOfLine = true;
         } else if (pos > start) {
-            if (mAtStartOfLine) {
-                fprintf(mFile, "%s", mLinePrefix.c_str());
-                fprintf(mFile, "%*s", (int)(4 * mIndentDepth), "");
-            }
-
             output(out.substr(start, pos - start + 1));
-
             mAtStartOfLine = true;
         }
 
@@ -148,10 +151,11 @@
     return *this;
 }
 
-#define FORMATTER_INPUT_INTEGER(__type__)               \
-    Formatter &Formatter::operator<<(__type__ n) {      \
-        return (*this) << std::to_string(n);            \
-    }                                                   \
+// NOLINT to suppress missing parentheses warning about __type__.
+#define FORMATTER_INPUT_INTEGER(__type__)                       \
+    Formatter& Formatter::operator<<(__type__ n) { /* NOLINT */ \
+        return (*this) << std::to_string(n);                    \
+    }
 
 FORMATTER_INPUT_INTEGER(short);
 FORMATTER_INPUT_INTEGER(unsigned short);
@@ -167,10 +171,11 @@
 
 #undef FORMATTER_INPUT_INTEGER
 
-#define FORMATTER_INPUT_CHAR(__type__)                  \
-    Formatter &Formatter::operator<<(__type__ c) {      \
-        return (*this) << std::string(1, (char)c);    \
-    }                                                   \
+// NOLINT to suppress missing parentheses warning about __type__.
+#define FORMATTER_INPUT_CHAR(__type__)                          \
+    Formatter& Formatter::operator<<(__type__ c) { /* NOLINT */ \
+        return (*this) << std::string(1, (char)c);              \
+    }
 
 FORMATTER_INPUT_CHAR(char);
 FORMATTER_INPUT_CHAR(signed char);
@@ -182,24 +187,12 @@
     mSpace = space;
 }
 
+bool Formatter::isValid() const {
+    return mFile != nullptr;
+}
+
 void Formatter::output(const std::string &text) const {
-    const size_t spaceLength = mSpace.size();
-    if (spaceLength > 0) {
-        // Remove all occurences of "mSpace" and output the filtered result.
-        size_t matchPos = text.find(mSpace);
-        if (matchPos != std::string::npos) {
-            std::string newText = text.substr(0, matchPos);
-            size_t startPos = matchPos + spaceLength;
-            while ((matchPos = text.find(mSpace, startPos))
-                    != std::string::npos) {
-                newText.append(text.substr(startPos, matchPos - startPos));
-                startPos = matchPos + spaceLength;
-            }
-            newText.append(text.substr(startPos));
-            fprintf(mFile, "%s", newText.c_str());
-            return;
-        }
-    }
+    CHECK(isValid());
 
     fprintf(mFile, "%s", text.c_str());
 }
diff --git a/utils/FqInstance.cpp b/utils/FqInstance.cpp
new file mode 100644
index 0000000..0b2b8f8
--- /dev/null
+++ b/utils/FqInstance.cpp
@@ -0,0 +1,129 @@
+/*
+ * Copyright (C) 2018 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "FqInstance.h"
+
+#include <sstream>
+
+namespace android {
+
+static const char INSTANCE_SEP = '/';
+
+const std::string& FqInstance::getPackage() const {
+    return mFqName.package();
+}
+
+bool FqInstance::hasPackage() const {
+    return !getPackage().empty();
+}
+
+size_t FqInstance::getMajorVersion() const {
+    return hasVersion() ? mFqName.getPackageMajorVersion() : 0;
+}
+
+size_t FqInstance::getMinorVersion() const {
+    return hasVersion() ? mFqName.getPackageMinorVersion() : 0;
+}
+
+std::pair<size_t, size_t> FqInstance::getVersion() const {
+    return {getMajorVersion(), getMinorVersion()};
+}
+
+bool FqInstance::hasVersion() const {
+    return mFqName.hasVersion();
+}
+
+const std::string& FqInstance::getInterface() const {
+    return mFqName.getInterfaceName();
+}
+
+bool FqInstance::hasInterface() const {
+    return mFqName.isInterfaceName();
+}
+
+const std::string& FqInstance::getInstance() const {
+    return mInstance;
+}
+
+bool FqInstance::hasInstance() const {
+    return !mInstance.empty();
+}
+
+bool FqInstance::setTo(const std::string& s) {
+    auto pos = s.find(INSTANCE_SEP);
+    if (!mFqName.setTo(s.substr(0, pos))) return false;
+    mInstance = pos == std::string::npos ? std::string{} : s.substr(pos + 1);
+
+    bool hasPkg = hasPackage();
+    bool hasVer = hasVersion();
+    bool hasIntf = hasInterface();
+    bool hasInst = hasInstance();
+
+    // android.hardware.foo@1.0::IFoo/default
+    if (hasPkg && hasVer && hasIntf && hasInst) {
+        return true;
+    }
+
+    // @1.0::IFoo/default
+    if (!hasPkg && hasVer && hasIntf && hasInst) {
+        return true;
+    }
+
+    // IFoo/default
+    if (!hasPkg && !hasVer && hasIntf && hasInst) {
+        return true;
+    }
+
+    // Other cases are covered by FQName::setTo, but instance name should be empty.
+    return !hasInst;
+}
+
+bool FqInstance::setTo(const std::string& package, size_t majorVer, size_t minorVer,
+                       const std::string& interface, const std::string& instance) {
+    std::stringstream ss;
+    ss << package << "@" << majorVer << "." << minorVer << "::" << interface << INSTANCE_SEP
+       << instance;
+    return setTo(ss.str());
+}
+
+bool FqInstance::setTo(size_t majorVer, size_t minorVer, const std::string& interface,
+                       const std::string& instance) {
+    return setTo("", majorVer, minorVer, interface, instance);
+}
+
+bool FqInstance::setTo(const std::string& interface, const std::string& instance) {
+    return setTo(interface + INSTANCE_SEP + instance);
+}
+
+std::string FqInstance::string() const {
+    std::string ret = mFqName.string();
+    if (hasInstance()) ret += INSTANCE_SEP + mInstance;
+    return ret;
+}
+
+bool FqInstance::operator<(const FqInstance& other) const {
+    return string() < other.string();
+}
+
+bool FqInstance::operator==(const FqInstance& other) const {
+    return string() == other.string();
+}
+
+bool FqInstance::operator!=(const FqInstance& other) const {
+    return !(*this == other);
+}
+
+}  // namespace android
diff --git a/utils/StringHelper.cpp b/utils/StringHelper.cpp
index 3718d53..aae9b5a 100644
--- a/utils/StringHelper.cpp
+++ b/utils/StringHelper.cpp
@@ -184,6 +184,10 @@
 }
 
 std::string StringHelper::RTrimAll(const std::string &in, const std::string &suffix) {
+    if (suffix.empty()) {
+        return in;
+    }
+
     std::string copy(in);
     while (EndsWith(copy, suffix)) {
         copy = copy.substr(0, copy.size() - suffix.size());
@@ -193,6 +197,10 @@
 }
 
 std::string StringHelper::LTrimAll(const std::string &in, const std::string &prefix) {
+    if (prefix.empty()) {
+        return in;
+    }
+
     std::string copy(in);
     while (StartsWith(copy, prefix)) {
         copy = copy.substr(prefix.size());
diff --git a/utils/include/hidl-util/FQName.h b/utils/include/hidl-util/FQName.h
index 3cdc7a9..3e31431 100644
--- a/utils/include/hidl-util/FQName.h
+++ b/utils/include/hidl-util/FQName.h
@@ -18,35 +18,35 @@
 
 #define FQNAME_H_
 
-#include <android-base/macros.h>
 #include <string>
 #include <vector>
 
 namespace android {
 
 struct FQName {
+    __attribute__((warn_unused_result)) static bool parse(const std::string& s, FQName* into);
+
     explicit FQName();
+
+    // TODO(b/73774955): delete
     explicit FQName(const std::string &s);
 
-    FQName(const std::string &package,
-           const std::string &version,
-           const std::string &name,
-           const std::string &valueName = "");
-
-    // a synonym to FQName(names.join("."))
-    FQName(const std::vector<std::string> &names);
+    FQName(const std::string& package, const std::string& version, const std::string& name = "",
+           const std::string& valueName = "");
 
     FQName(const FQName& other);
 
     bool isValid() const;
     bool isIdentifier() const;
-    bool setTo(const std::string &s);
+
+    // Returns false if string isn't a valid FQName object.
+    __attribute__((warn_unused_result)) bool setTo(const std::string& s);
 
     void applyDefaults(
             const std::string &defaultPackage,
             const std::string &defaultVersion);
 
-    std::string package() const;
+    const std::string& package() const;
     // Return version in the form "@1.0" if it is present, otherwise empty string.
     std::string atVersion() const;
     // Return version in the form "1.0" if it is present, otherwise empty string.
@@ -56,6 +56,8 @@
     // Return true only if version is present.
     bool hasVersion() const;
 
+    FQName withVersion(size_t major, size_t minor) const;
+
     // The next two methods return the name part of the FQName, that is, the
     // part after the version field.  For example:
     //
@@ -80,13 +82,13 @@
     // FQName::name() will return "IFoo.bar.baz". FQName::names() will return
     // std::vector<std::string>{"IFoo","bar","baz"}
 
-    std::string name() const;
+    const std::string& name() const;
     std::vector<std::string> names() const;
 
     // The next two methods returns two parts of the FQName, that is,
     // the first part package + version + name, the second part valueName.
     FQName typeName() const;
-    std::string valueName() const;
+    const std::string& valueName() const;
 
     // has package version and name
     bool isFullyQualified() const;
@@ -96,7 +98,9 @@
     // 2. (valueName), aka a single identifier
     bool isValidValueName() const;
 
-    void print() const;
+    // Interface names start with 'I'
+    bool isInterfaceName() const;
+
     std::string string() const;
 
     bool operator<(const FQName &other) const;
@@ -110,8 +114,13 @@
 
     // Must be called on an interface
     // android.hardware.foo@1.0::IBar
+    // -> ABar
+    std::string getInterfaceAdapterName() const;
+
+    // Must be called on an interface
+    // android.hardware.foo@1.0::IBar
     // -> IBar
-    std::string getInterfaceName() const;
+    const std::string& getInterfaceName() const;
 
     // Must be called on an interface
     // android.hardware.foo@1.0::IBar
@@ -120,12 +129,12 @@
 
     // Must be called on an interface
     // android.hardware.foo@1.0::IBar
-    // -> BpBar
+    // -> BpHwBar
     std::string getInterfaceProxyName() const;
 
     // Must be called on an interface
     // android.hardware.foo@1.0::IBar
-    // -> BnBar
+    // -> BnHwBar
     std::string getInterfaceStubName() const;
 
     // Must be called on an interface
@@ -140,6 +149,11 @@
 
     // Must be called on an interface
     // android.hardware.foo@1.0::IBar
+    // -> android.hardware.foo@1.0::ABar
+    FQName getInterfaceAdapterFqName() const;
+
+    // Must be called on an interface
+    // android.hardware.foo@1.0::IBar
     // -> android.hardware.foo@1.0::BnBar
     FQName getInterfaceStubFqName() const;
 
@@ -210,8 +224,10 @@
     // minor-- if result doesn't underflow, else abort.
     FQName downRev() const;
 
-private:
+   private:
+    // TODO(b/73774955): remove
     bool mValid;
+
     bool mIsIdentifier;
     std::string mPackage;
     // mMajor == 0 means empty.
@@ -220,15 +236,16 @@
     std::string mName;
     std::string mValueName;
 
-    void setVersion(const std::string &v);
+    void clear();
+
+    __attribute__((warn_unused_result)) bool setVersion(const std::string& v);
+    __attribute__((warn_unused_result)) bool parseVersion(const std::string& majorStr,
+                                                          const std::string& minorStr);
     void clearVersion();
-    void parseVersion(const std::string &majorStr, const std::string &minorStr);
 };
 
-static const FQName gIBaseFqName = FQName{"android.hidl.base@1.0::IBase"};
-static const FQName gIBasePackageFqName = FQName{"android.hidl.base"};
-static const FQName gIManagerFqName = FQName{"android.hidl.manager@1.0::IServiceManager"};
-static const FQName gIManagerPackageFqName = FQName{"android.hidl.manager"};
+extern const FQName gIBaseFqName;
+extern const FQName gIManagerFqName;
 
 }  // namespace android
 
diff --git a/utils/include/hidl-util/Formatter.h b/utils/include/hidl-util/Formatter.h
index bb4288b..053563f 100644
--- a/utils/include/hidl-util/Formatter.h
+++ b/utils/include/hidl-util/Formatter.h
@@ -18,7 +18,6 @@
 
 #define FORMATTER_H_
 
-#include <android-base/macros.h>
 #include <functional>
 #include <string>
 
@@ -30,9 +29,11 @@
 // The other is with chain calls and lambda functions
 //     out.sIf("good", [&] { out("blah").endl()("blah").endl(); }).endl();
 struct Formatter {
+    static Formatter invalid() { return Formatter(); }
 
     // Assumes ownership of file. Directed to stdout if file == NULL.
-    Formatter(FILE *file = NULL);
+    Formatter(FILE* file, size_t spacesPerIndent = 4);
+    Formatter(Formatter&&) = default;
     ~Formatter();
 
     void indent(size_t level = 1);
@@ -42,13 +43,13 @@
     // out.indent(2, [&] {
     //     out << "Meow\n";
     // });
-    Formatter &indent(size_t level, std::function<void(void)> func);
+    Formatter& indent(size_t level, const std::function<void(void)>& func);
 
     // Note that The last \n after the last line is NOT added automatically.
     // out.indent([&] {
     //     out << "Meow\n";
     // });
-    Formatter &indent(std::function<void(void)> func);
+    Formatter& indent(const std::function<void(void)>& func);
 
     // A block inside braces.
     // * No space will be added before the opening brace.
@@ -62,7 +63,7 @@
     // out << "{\n"
     //     << "one();\ntwo();\n" // func()
     //     << "}";
-    Formatter &block(std::function<void(void)> func);
+    Formatter& block(const std::function<void(void)>& func);
 
     // A synonym to (*this) << "\n";
     Formatter &endl();
@@ -75,14 +76,14 @@
     //     out << "logFatal();\n";
     // }).endl();
     // note that there will be a space before the "else"-s.
-    Formatter &sIf(const std::string &cond, std::function<void(void)> block);
-    Formatter &sElseIf(const std::string &cond, std::function<void(void)> block);
-    Formatter &sElse(std::function<void(void)> block);
+    Formatter& sIf(const std::string& cond, const std::function<void(void)>& block);
+    Formatter& sElseIf(const std::string& cond, const std::function<void(void)>& block);
+    Formatter& sElse(const std::function<void(void)>& block);
 
     // out.sFor("int i = 0; i < 10; i++", [&] {
     //     out << "printf(\"%d\", i);\n";
     // }).endl();
-    Formatter &sFor(const std::string &stmts, std::function<void(void)> block);
+    Formatter& sFor(const std::string& stmts, const std::function<void(void)>& block);
 
     // out.sTry([&] {
     //     out << "throw RemoteException();\n"
@@ -92,21 +93,22 @@
     //     // cleanup
     // }).endl();
     // note that there will be a space before the "catch"-s.
-    Formatter &sTry(std::function<void(void)> block);
-    Formatter &sCatch(const std::string &exception, std::function<void(void)> block);
-    Formatter &sFinally(std::function<void(void)> block);
+    Formatter& sTry(const std::function<void(void)>& block);
+    Formatter& sCatch(const std::string& exception, const std::function<void(void)>& block);
+    Formatter& sFinally(const std::function<void(void)>& block);
 
     // out.sWhile("z < 10", [&] {
     //     out << "z++;\n";
     // }).endl();
-    Formatter &sWhile(const std::string &cond, std::function<void(void)> block);
+    Formatter& sWhile(const std::string& cond, const std::function<void(void)>& block);
 
     // out.join(v.begin(), v.end(), ",", [&](const auto &e) {
     //     out << toString(e);
     // });
-    template<typename I>
-    Formatter &join(const I begin, const I end, const std::string &separator,
-            std::function<void(const typename std::iterator_traits<I>::value_type &)> func);
+    template <typename I>
+    Formatter& join(
+        const I begin, const I end, const std::string& separator,
+        const std::function<void(const typename std::iterator_traits<I>::value_type&)>& func);
 
     Formatter &operator<<(const std::string &out);
 
@@ -137,9 +139,15 @@
     // Remove the line prefix.
     void unsetLinePrefix();
 
-private:
-    FILE *mFile;
+    bool isValid() const;
+
+   private:
+    // Creates an invalid formatter object.
+    Formatter();
+
+    FILE* mFile;  // invalid if nullptr
     size_t mIndentDepth;
+    size_t mSpacesPerIndent;
     bool mAtStartOfLine;
 
     std::string mSpace;
@@ -147,12 +155,14 @@
 
     void output(const std::string &text) const;
 
-    DISALLOW_COPY_AND_ASSIGN(Formatter);
+    Formatter(const Formatter&) = delete;
+    void operator=(const Formatter&) = delete;
 };
 
-template<typename I>
-Formatter &Formatter::join(const I begin, const I end, const std::string &separator,
-        std::function<void(const typename std::iterator_traits<I>::value_type &)> func) {
+template <typename I>
+Formatter& Formatter::join(
+    const I begin, const I end, const std::string& separator,
+    const std::function<void(const typename std::iterator_traits<I>::value_type&)>& func) {
     for (I iter = begin; iter != end; ++iter) {
         if (iter != begin) {
             (*this) << separator;
diff --git a/utils/include/hidl-util/FqInstance.h b/utils/include/hidl-util/FqInstance.h
new file mode 100644
index 0000000..bdd0043
--- /dev/null
+++ b/utils/include/hidl-util/FqInstance.h
@@ -0,0 +1,97 @@
+/*
+ * Copyright (C) 2018 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ANDROID_FQINSTANCE_H_
+
+#define ANDROID_FQINSTANCE_H_
+
+#include <string>
+#include <utility>
+
+#include <hidl-util/FQName.h>
+
+namespace android {
+
+// A wrapper around FQName to include instance name as well.
+// FqInstance::setTo also recognizes all FQName formats, including enum names
+// etc.
+// Typical usage:
+// FqInstance fqInstance;
+// if (!fqInstance.setTo("...")) {
+//    // error handling
+// }
+// LOG(WARNING) << fqInstance.string();
+class FqInstance {
+   public:
+    const std::string& getPackage() const;
+    size_t getMajorVersion() const;
+    size_t getMinorVersion() const;
+    std::pair<size_t, size_t> getVersion() const;
+    const std::string& getInterface() const;
+    const std::string& getInstance() const;
+
+    bool hasPackage() const;
+    bool hasVersion() const;
+    bool hasInterface() const;
+    bool hasInstance() const;
+
+    // Return true if valid:
+    // android.hardware.foo@1.0::IFoo/instance
+    // @1.0::IFoo/instance
+    // IFoo/instance
+    // android.hardware.foo@1.0::IFoo.Type
+    // @1.0::IFoo.Type
+    // android.hardware.foo@1.0
+    // IFoo.Type
+    // Type
+    // android.hardware.foo@1.0::IFoo.Type:MY_ENUM_VALUE
+    // @1.0::IFoo.Type:MY_ENUM_VALUE
+    // IFoo.Type:MY_ENUM_VALUE
+    //
+    // If no "/instance", hasInstance() will return false afterwards.
+    // TODO(b/73774955): deprecate this and use std::optional.
+    __attribute__((warn_unused_result)) bool setTo(const std::string& s);
+
+    // Convenience method for the following formats:
+    // android.hardware.foo@1.0::IFoo/default
+    // @1.0::IFoo/default
+    // IFoo/default
+    __attribute__((warn_unused_result)) bool setTo(const std::string& package, size_t majorVer,
+                                                   size_t minorVer, const std::string& interface,
+                                                   const std::string& instance);
+    __attribute__((warn_unused_result)) bool setTo(size_t majorVer, size_t minorVer,
+                                                   const std::string& interface,
+                                                   const std::string& instance);
+    __attribute__((warn_unused_result)) bool setTo(const std::string& interface,
+                                                   const std::string& instance);
+
+    // undefined behavior if:
+    // - Default constructor is called without setTo();
+    // - setTo is called but returned false.
+    // Should only be called after setTo() returns true.
+    std::string string() const;
+    bool operator<(const FqInstance& other) const;
+    bool operator==(const FqInstance& other) const;
+    bool operator!=(const FqInstance& other) const;
+
+   private:
+    FQName mFqName;
+    std::string mInstance;
+};
+
+}  // namespace android
+
+#endif  // ANDROID_FQINSTANCE_H_
diff --git a/utils/include/hidl-util/StringHelper.h b/utils/include/hidl-util/StringHelper.h
index 277367b..51a47a0 100644
--- a/utils/include/hidl-util/StringHelper.h
+++ b/utils/include/hidl-util/StringHelper.h
@@ -19,7 +19,6 @@
 #define STRING_HELPER_H_
 
 #include <string>
-#include <android-base/macros.h>
 #include <vector>
 
 namespace android {
@@ -80,12 +79,10 @@
         const std::string &separator);
 
 private:
-    StringHelper() {}
+    StringHelper() = delete;
 
     static void Tokenize(const std::string &in,
         std::vector<std::string> *vec);
-
-    DISALLOW_COPY_AND_ASSIGN(StringHelper);
 };
 
 }  // namespace android