tools/aapt2/link/TableMerger.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 "link/TableMerger.h"

#include "android-base/logging.h"

#include "ResourceTable.h"
#include "ResourceUtils.h"
#include "ResourceValues.h"
#include "ValueVisitor.h"
#include "util/Util.h"

using android::StringPiece;

namespace aapt {

TableMerger::TableMerger(IAaptContext* context, ResourceTable* out_table,
                         const TableMergerOptions& options)
    : context_(context), master_table_(out_table), options_(options) {
  // Create the desired package that all tables will be merged into.
  master_package_ = master_table_->CreatePackage(
      context_->GetCompilationPackage(), context_->GetPackageId());
  CHECK(master_package_ != nullptr) << "package name or ID already taken";
}

bool TableMerger::Merge(const Source& src, ResourceTable* table,
                        io::IFileCollection* collection) {
  return MergeImpl(src, table, collection, false /* overlay */, true /* allow new */);
}

bool TableMerger::MergeOverlay(const Source& src, ResourceTable* table,
                               io::IFileCollection* collection) {
  return MergeImpl(src, table, collection, true /* overlay */, options_.auto_add_overlay);
}

/**
 * This will merge packages with the same package name (or no package name).
 */
bool TableMerger::MergeImpl(const Source& src, ResourceTable* table,
                            io::IFileCollection* collection, bool overlay,
                            bool allow_new) {
  bool error = false;
  for (auto& package : table->packages) {
    // Only merge an empty package or the package we're building.
    // Other packages may exist, which likely contain attribute definitions.
    // This is because at compile time it is unknown if the attributes are
    // simply uses of the attribute or definitions.
    if (package->name.empty() || context_->GetCompilationPackage() == package->name) {
      FileMergeCallback callback;
      if (collection) {
        callback = [&](const ResourceNameRef& name,
                       const ConfigDescription& config, FileReference* new_file,
                       FileReference* old_file) -> bool {
          // The old file's path points inside the APK, so we can use it as is.
          io::IFile* f = collection->FindFile(*old_file->path);
          if (!f) {
            context_->GetDiagnostics()->Error(DiagMessage(src)
                                              << "file '" << *old_file->path << "' not found");
            return false;
          }

          new_file->file = f;
          return true;
        };
      }

      // Merge here. Once the entries are merged and mangled, any references to
      // them are still valid. This is because un-mangled references are
      // mangled, then looked up at resolution time.
      // Also, when linking, we convert references with no package name to use
      // the compilation package name.
      error |= !DoMerge(src, table, package.get(), false /* mangle */, overlay,
                        allow_new, callback);
    }
  }
  return !error;
}

/**
 * This will merge and mangle resources from a static library.
 */
bool TableMerger::MergeAndMangle(const Source& src,
                                 const StringPiece& package_name,
                                 ResourceTable* table,
                                 io::IFileCollection* collection) {
  bool error = false;
  for (auto& package : table->packages) {
    // Warn of packages with an unrelated ID.
    if (package_name != package->name) {
      context_->GetDiagnostics()->Warn(DiagMessage(src) << "ignoring package "
                                                        << package->name);
      continue;
    }

    bool mangle = package_name != context_->GetCompilationPackage();
    merged_packages_.insert(package->name);

    auto callback = [&](
        const ResourceNameRef& name, const ConfigDescription& config,
        FileReference* new_file, FileReference* old_file) -> bool {
      // The old file's path points inside the APK, so we can use it as is.
      io::IFile* f = collection->FindFile(*old_file->path);
      if (!f) {
        context_->GetDiagnostics()->Error(
            DiagMessage(src) << "file '" << *old_file->path << "' not found");
        return false;
      }

      new_file->file = f;
      return true;
    };

    error |= !DoMerge(src, table, package.get(), mangle, false /* overlay */,
                      true /* allow new */, callback);
  }
  return !error;
}

static bool MergeType(IAaptContext* context, const Source& src,
                      ResourceTableType* dst_type,
                      ResourceTableType* src_type) {
  if (dst_type->symbol_status.state < src_type->symbol_status.state) {
    // The incoming type's visibility is stronger, so we should override
    // the visibility.
    if (src_type->symbol_status.state == SymbolState::kPublic) {
      // Only copy the ID if the source is public, or else the ID is
      // meaningless.
      dst_type->id = src_type->id;
    }
    dst_type->symbol_status = std::move(src_type->symbol_status);
  } else if (dst_type->symbol_status.state == SymbolState::kPublic &&
             src_type->symbol_status.state == SymbolState::kPublic &&
             dst_type->id && src_type->id &&
             dst_type->id.value() != src_type->id.value()) {
    // Both types are public and have different IDs.
    context->GetDiagnostics()->Error(DiagMessage(src)
                                     << "cannot merge type '" << src_type->type
                                     << "': conflicting public IDs");
    return false;
  }
  return true;
}

static bool MergeEntry(IAaptContext* context, const Source& src,
                       ResourceEntry* dst_entry, ResourceEntry* src_entry) {
  if (dst_entry->symbol_status.state < src_entry->symbol_status.state) {
    // The incoming type's visibility is stronger, so we should override
    // the visibility.
    if (src_entry->symbol_status.state == SymbolState::kPublic) {
      // Only copy the ID if the source is public, or else the ID is
      // meaningless.
      dst_entry->id = src_entry->id;
    }
    dst_entry->symbol_status = std::move(src_entry->symbol_status);
  } else if (src_entry->symbol_status.state == SymbolState::kPublic &&
             dst_entry->symbol_status.state == SymbolState::kPublic &&
             dst_entry->id && src_entry->id &&
             dst_entry->id.value() != src_entry->id.value()) {
    // Both entries are public and have different IDs.
    context->GetDiagnostics()->Error(
        DiagMessage(src) << "cannot merge entry '" << src_entry->name
                         << "': conflicting public IDs");
    return false;
  }
  return true;
}

// Modified CollisionResolver which will merge Styleables and Styles. Used with overlays.
//
// Styleables are not actual resources, but they are treated as such during the
// compilation phase.
//
// Styleables and Styles don't simply overlay each other, their definitions merge
// and accumulate. If both values are Styleables/Styles, we just merge them into the
// existing value.
static ResourceTable::CollisionResult ResolveMergeCollision(Value* existing, Value* incoming,
                                                            StringPool* pool) {
  if (Styleable* existing_styleable = ValueCast<Styleable>(existing)) {
    if (Styleable* incoming_styleable = ValueCast<Styleable>(incoming)) {
      // Styleables get merged.
      existing_styleable->MergeWith(incoming_styleable);
      return ResourceTable::CollisionResult::kKeepOriginal;
    }
  } else if (Style* existing_style = ValueCast<Style>(existing)) {
    if (Style* incoming_style = ValueCast<Style>(incoming)) {
      // Styles get merged.
      existing_style->MergeWith(incoming_style, pool);
      return ResourceTable::CollisionResult::kKeepOriginal;
    }
  }
  // Delegate to the default handler.
  return ResourceTable::ResolveValueCollision(existing, incoming);
}

static ResourceTable::CollisionResult MergeConfigValue(IAaptContext* context,
                                                       const ResourceNameRef& res_name,
                                                       const bool overlay,
                                                       ResourceConfigValue* dst_config_value,
                                                       ResourceConfigValue* src_config_value,
                                                       StringPool* pool) {
  using CollisionResult = ResourceTable::CollisionResult;

  Value* dst_value = dst_config_value->value.get();
  Value* src_value = src_config_value->value.get();

  CollisionResult collision_result;
  if (overlay) {
    collision_result = ResolveMergeCollision(dst_value, src_value, pool);
  } else {
    collision_result = ResourceTable::ResolveValueCollision(dst_value, src_value);
  }

  if (collision_result == CollisionResult::kConflict) {
    if (overlay) {
      return CollisionResult::kTakeNew;
    }

    // Error!
    context->GetDiagnostics()->Error(DiagMessage(src_value->GetSource())
                                     << "resource '" << res_name << "' has a conflicting value for "
                                     << "configuration (" << src_config_value->config << ")");
    context->GetDiagnostics()->Note(DiagMessage(dst_value->GetSource())
                                    << "originally defined here");
    return CollisionResult::kConflict;
  }
  return collision_result;
}

bool TableMerger::DoMerge(const Source& src, ResourceTable* src_table,
                          ResourceTablePackage* src_package,
                          const bool mangle_package, const bool overlay,
                          const bool allow_new_resources,
                          const FileMergeCallback& callback) {
  bool error = false;

  for (auto& src_type : src_package->types) {
    ResourceTableType* dst_type = master_package_->FindOrCreateType(src_type->type);
    if (!MergeType(context_, src, dst_type, src_type.get())) {
      error = true;
      continue;
    }

    for (auto& src_entry : src_type->entries) {
      std::string entry_name = src_entry->name;
      if (mangle_package) {
        entry_name = NameMangler::MangleEntry(src_package->name, src_entry->name);
      }

      ResourceEntry* dst_entry;
      if (allow_new_resources || src_entry->symbol_status.allow_new) {
        dst_entry = dst_type->FindOrCreateEntry(entry_name);
      } else {
        dst_entry = dst_type->FindEntry(entry_name);
      }

      const ResourceNameRef res_name(src_package->name, src_type->type, src_entry->name);

      if (!dst_entry) {
        context_->GetDiagnostics()->Error(DiagMessage(src)
                                          << "resource " << res_name
                                          << " does not override an existing resource");
        context_->GetDiagnostics()->Note(DiagMessage(src) << "define an <add-resource> tag or use "
                                                          << "--auto-add-overlay");
        error = true;
        continue;
      }

      if (!MergeEntry(context_, src, dst_entry, src_entry.get())) {
        error = true;
        continue;
      }

      for (auto& src_config_value : src_entry->values) {
        using CollisionResult = ResourceTable::CollisionResult;

        ResourceConfigValue* dst_config_value = dst_entry->FindValue(
            src_config_value->config, src_config_value->product);
        if (dst_config_value) {
          CollisionResult collision_result =
              MergeConfigValue(context_, res_name, overlay, dst_config_value,
                               src_config_value.get(), &master_table_->string_pool);
          if (collision_result == CollisionResult::kConflict) {
            error = true;
            continue;
          } else if (collision_result == CollisionResult::kKeepOriginal) {
            continue;
          }
        } else {
          dst_config_value =
              dst_entry->FindOrCreateValue(src_config_value->config, src_config_value->product);
        }

        // Continue if we're taking the new resource.

        if (FileReference* f = ValueCast<FileReference>(src_config_value->value.get())) {
          std::unique_ptr<FileReference> new_file_ref;
          if (mangle_package) {
            new_file_ref = CloneAndMangleFile(src_package->name, *f);
          } else {
            new_file_ref = std::unique_ptr<FileReference>(f->Clone(&master_table_->string_pool));
          }

          if (callback) {
            if (!callback(res_name, src_config_value->config, new_file_ref.get(), f)) {
              error = true;
              continue;
            }
          }
          dst_config_value->value = std::move(new_file_ref);

        } else {
          dst_config_value->value = std::unique_ptr<Value>(
              src_config_value->value->Clone(&master_table_->string_pool));
        }
      }
    }
  }
  return !error;
}

std::unique_ptr<FileReference> TableMerger::CloneAndMangleFile(
    const std::string& package, const FileReference& file_ref) {
  StringPiece prefix, entry, suffix;
  if (util::ExtractResFilePathParts(*file_ref.path, &prefix, &entry, &suffix)) {
    std::string mangled_entry = NameMangler::MangleEntry(package, entry.to_string());
    std::string newPath = prefix.to_string() + mangled_entry + suffix.to_string();
    std::unique_ptr<FileReference> new_file_ref =
        util::make_unique<FileReference>(master_table_->string_pool.MakeRef(newPath));
    new_file_ref->SetComment(file_ref.GetComment());
    new_file_ref->SetSource(file_ref.GetSource());
    return new_file_ref;
  }
  return std::unique_ptr<FileReference>(file_ref.Clone(&master_table_->string_pool));
}

bool TableMerger::MergeFileImpl(const ResourceFile& file_desc, io::IFile* file, bool overlay) {
  ResourceTable table;
  std::string path = ResourceUtils::BuildResourceFileName(file_desc);
  std::unique_ptr<FileReference> file_ref =
      util::make_unique<FileReference>(table.string_pool.MakeRef(path));
  file_ref->SetSource(file_desc.source);
  file_ref->file = file;

  ResourceTablePackage* pkg = table.CreatePackage(file_desc.name.package, 0x0);
  pkg->FindOrCreateType(file_desc.name.type)
      ->FindOrCreateEntry(file_desc.name.entry)
      ->FindOrCreateValue(file_desc.config, {})
      ->value = std::move(file_ref);

  return DoMerge(file->GetSource(), &table, pkg, false /* mangle */,
                 overlay /* overlay */, true /* allow_new */, {});
}

bool TableMerger::MergeFile(const ResourceFile& file_desc, io::IFile* file) {
  return MergeFileImpl(file_desc, file, false /* overlay */);
}

bool TableMerger::MergeFileOverlay(const ResourceFile& file_desc,
                                   io::IFile* file) {
  return MergeFileImpl(file_desc, file, true /* overlay */);
}

}  // namespace aapt