tools/aapt2/link/ReferenceLinker.cpp

/*
 * Copyright (C) 2015 The Android Open Source Project
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

#include "ReferenceLinker.h"
#include "Diagnostics.h"
#include "ResourceTable.h"
#include "ResourceUtils.h"
#include "ResourceValues.h"
#include "ValueVisitor.h"
#include "link/Linkers.h"
#include "process/IResourceTableConsumer.h"
#include "process/SymbolTable.h"
#include "util/Util.h"
#include "xml/XmlUtil.h"

#include <androidfw/ResourceTypes.h>
#include <cassert>

namespace aapt {

namespace {

/**
 * The ReferenceLinkerVisitor will follow all references and make sure they
 * point
 * to resources that actually exist, either in the local resource table, or as
 * external
 * symbols. Once the target resource has been found, the ID of the resource will
 * be assigned
 * to the reference object.
 *
 * NOTE: All of the entries in the ResourceTable must be assigned IDs.
 */
class ReferenceLinkerVisitor : public ValueVisitor {
 public:
  using ValueVisitor::visit;

  ReferenceLinkerVisitor(IAaptContext* context, SymbolTable* symbols,
                         StringPool* stringPool, xml::IPackageDeclStack* decl,
                         CallSite* callSite)
      : mContext(context),
        mSymbols(symbols),
        mPackageDecls(decl),
        mStringPool(stringPool),
        mCallSite(callSite) {}

  void visit(Reference* ref) override {
    if (!ReferenceLinker::linkReference(ref, mContext, mSymbols, mPackageDecls,
                                        mCallSite)) {
      mError = true;
    }
  }

  /**
   * We visit the Style specially because during this phase, values of
   * attributes are
   * all RawString values. Now that we are expected to resolve all symbols, we
   * can
   * lookup the attributes to find out which types are allowed for the
   * attributes' values.
   */
  void visit(Style* style) override {
    if (style->parent) {
      visit(&style->parent.value());
    }

    for (Style::Entry& entry : style->entries) {
      std::string errStr;

      // Transform the attribute reference so that it is using the fully
      // qualified package
      // name. This will also mark the reference as being able to see private
      // resources if
      // there was a '*' in the reference or if the package came from the
      // private namespace.
      Reference transformedReference = entry.key;
      transformReferenceFromNamespace(mPackageDecls,
                                      mContext->getCompilationPackage(),
                                      &transformedReference);

      // Find the attribute in the symbol table and check if it is visible from
      // this callsite.
      const SymbolTable::Symbol* symbol =
          ReferenceLinker::resolveAttributeCheckVisibility(
              transformedReference, mContext->getNameMangler(), mSymbols,
              mCallSite, &errStr);
      if (symbol) {
        // Assign our style key the correct ID.
        // The ID may not exist.
        entry.key.id = symbol->id;

        // Try to convert the value to a more specific, typed value based on the
        // attribute it is set to.
        entry.value = parseValueWithAttribute(std::move(entry.value),
                                              symbol->attribute.get());

        // Link/resolve the final value (mostly if it's a reference).
        entry.value->accept(this);

        // Now verify that the type of this item is compatible with the
        // attribute it
        // is defined for. We pass `nullptr` as the DiagMessage so that this
        // check is
        // fast and we avoid creating a DiagMessage when the match is
        // successful.
        if (!symbol->attribute->matches(entry.value.get(), nullptr)) {
          // The actual type of this item is incompatible with the attribute.
          DiagMessage msg(entry.key.getSource());

          // Call the matches method again, this time with a DiagMessage so we
          // fill
          // in the actual error message.
          symbol->attribute->matches(entry.value.get(), &msg);
          mContext->getDiagnostics()->error(msg);
          mError = true;
        }

      } else {
        DiagMessage msg(entry.key.getSource());
        msg << "style attribute '";
        ReferenceLinker::writeResourceName(&msg, entry.key,
                                           transformedReference);
        msg << "' " << errStr;
        mContext->getDiagnostics()->error(msg);
        mError = true;
      }
    }
  }

  bool hasError() { return mError; }

 private:
  IAaptContext* mContext;
  SymbolTable* mSymbols;
  xml::IPackageDeclStack* mPackageDecls;
  StringPool* mStringPool;
  CallSite* mCallSite;
  bool mError = false;

  /**
   * Transform a RawString value into a more specific, appropriate value, based
   * on the
   * Attribute. If a non RawString value is passed in, this is an identity
   * transform.
   */
  std::unique_ptr<Item> parseValueWithAttribute(std::unique_ptr<Item> value,
                                                const Attribute* attr) {
    if (RawString* rawString = valueCast<RawString>(value.get())) {
      std::unique_ptr<Item> transformed =
          ResourceUtils::tryParseItemForAttribute(*rawString->value, attr);

      // If we could not parse as any specific type, try a basic STRING.
      if (!transformed &&
          (attr->typeMask & android::ResTable_map::TYPE_STRING)) {
        util::StringBuilder stringBuilder;
        stringBuilder.append(*rawString->value);
        if (stringBuilder) {
          transformed = util::make_unique<String>(
              mStringPool->makeRef(stringBuilder.str()));
        }
      }

      if (transformed) {
        return transformed;
      }
    };
    return value;
  }
};

}  // namespace

/**
 * The symbol is visible if it is public, or if the reference to it is
 * requesting private access
 * or if the callsite comes from the same package.
 */
bool ReferenceLinker::isSymbolVisible(const SymbolTable::Symbol& symbol,
                                      const Reference& ref,
                                      const CallSite& callSite) {
  if (!symbol.isPublic && !ref.privateReference) {
    if (ref.name) {
      return callSite.resource.package == ref.name.value().package;
    } else if (ref.id && symbol.id) {
      return ref.id.value().packageId() == symbol.id.value().packageId();
    } else {
      return false;
    }
  }
  return true;
}

const SymbolTable::Symbol* ReferenceLinker::resolveSymbol(
    const Reference& reference, NameMangler* mangler, SymbolTable* symbols) {
  if (reference.name) {
    Maybe<ResourceName> mangled = mangler->mangleName(reference.name.value());
    return symbols->findByName(mangled ? mangled.value()
                                       : reference.name.value());
  } else if (reference.id) {
    return symbols->findById(reference.id.value());
  } else {
    return nullptr;
  }
}

const SymbolTable::Symbol* ReferenceLinker::resolveSymbolCheckVisibility(
    const Reference& reference, NameMangler* nameMangler, SymbolTable* symbols,
    CallSite* callSite, std::string* outError) {
  const SymbolTable::Symbol* symbol =
      resolveSymbol(reference, nameMangler, symbols);
  if (!symbol) {
    if (outError) *outError = "not found";
    return nullptr;
  }

  if (!isSymbolVisible(*symbol, reference, *callSite)) {
    if (outError) *outError = "is private";
    return nullptr;
  }
  return symbol;
}

const SymbolTable::Symbol* ReferenceLinker::resolveAttributeCheckVisibility(
    const Reference& reference, NameMangler* nameMangler, SymbolTable* symbols,
    CallSite* callSite, std::string* outError) {
  const SymbolTable::Symbol* symbol = resolveSymbolCheckVisibility(
      reference, nameMangler, symbols, callSite, outError);
  if (!symbol) {
    return nullptr;
  }

  if (!symbol->attribute) {
    if (outError) *outError = "is not an attribute";
    return nullptr;
  }
  return symbol;
}

Maybe<xml::AaptAttribute> ReferenceLinker::compileXmlAttribute(
    const Reference& reference, NameMangler* nameMangler, SymbolTable* symbols,
    CallSite* callSite, std::string* outError) {
  const SymbolTable::Symbol* symbol =
      resolveSymbol(reference, nameMangler, symbols);
  if (!symbol) {
    if (outError) *outError = "not found";
    return {};
  }

  if (!symbol->attribute) {
    if (outError) *outError = "is not an attribute";
    return {};
  }
  return xml::AaptAttribute{symbol->id, *symbol->attribute};
}

void ReferenceLinker::writeResourceName(DiagMessage* outMsg,
                                        const Reference& orig,
                                        const Reference& transformed) {
  assert(outMsg);

  if (orig.name) {
    *outMsg << orig.name.value();
    if (transformed.name.value() != orig.name.value()) {
      *outMsg << " (aka " << transformed.name.value() << ")";
    }
  } else {
    *outMsg << orig.id.value();
  }
}

bool ReferenceLinker::linkReference(Reference* reference, IAaptContext* context,
                                    SymbolTable* symbols,
                                    xml::IPackageDeclStack* decls,
                                    CallSite* callSite) {
  assert(reference);
  assert(reference->name || reference->id);

  Reference transformedReference = *reference;
  transformReferenceFromNamespace(decls, context->getCompilationPackage(),
                                  &transformedReference);

  std::string errStr;
  const SymbolTable::Symbol* s = resolveSymbolCheckVisibility(
      transformedReference, context->getNameMangler(), symbols, callSite,
      &errStr);
  if (s) {
    // The ID may not exist. This is fine because of the possibility of building
    // against
    // libraries without assigned IDs.
    // Ex: Linking against own resources when building a static library.
    reference->id = s->id;
    return true;
  }

  DiagMessage errorMsg(reference->getSource());
  errorMsg << "resource ";
  writeResourceName(&errorMsg, *reference, transformedReference);
  errorMsg << " " << errStr;
  context->getDiagnostics()->error(errorMsg);
  return false;
}

namespace {

struct EmptyDeclStack : public xml::IPackageDeclStack {
  Maybe<xml::ExtractedPackage> transformPackageAlias(
      const StringPiece& alias,
      const StringPiece& localPackage) const override {
    if (alias.empty()) {
      return xml::ExtractedPackage{localPackage.toString(), true /* private */};
    }
    return {};
  }
};

}  // namespace

bool ReferenceLinker::consume(IAaptContext* context, ResourceTable* table) {
  EmptyDeclStack declStack;
  bool error = false;
  for (auto& package : table->packages) {
    for (auto& type : package->types) {
      for (auto& entry : type->entries) {
        // Symbol state information may be lost if there is no value for the
        // resource.
        if (entry->symbolStatus.state != SymbolState::kUndefined &&
            entry->values.empty()) {
          context->getDiagnostics()->error(
              DiagMessage(entry->symbolStatus.source)
              << "no definition for declared symbol '"
              << ResourceNameRef(package->name, type->type, entry->name)
              << "'");
          error = true;
        }

        CallSite callSite = {
            ResourceNameRef(package->name, type->type, entry->name)};
        ReferenceLinkerVisitor visitor(context, context->getExternalSymbols(),
                                       &table->stringPool, &declStack,
                                       &callSite);

        for (auto& configValue : entry->values) {
          configValue->value->accept(&visitor);
        }

        if (visitor.hasError()) {
          error = true;
        }
      }
    }
  }
  return !error;
}

}  // namespace aapt