• Home
• com.google.javascript
• closure-compiler-linter
• v20200406
• source code
• ModuleRenaming.java

×

Project download

Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance.
Project price only 1 $

You can buy this project and download/modify it how often you want.

com.google.javascript.jscomp.ModuleRenaming Maven / Gradle / Ivy

/*
 * Copyright 2018 The Closure Compiler Authors.
 *
 * 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 com.google.javascript.jscomp;

import static com.google.common.base.Preconditions.checkNotNull;
import static com.google.common.base.Preconditions.checkState;

import com.google.auto.value.AutoValue;
import com.google.common.base.Preconditions;
import com.google.common.collect.Iterables;
import com.google.javascript.jscomp.modules.Binding;
import com.google.javascript.jscomp.modules.Export;
import com.google.javascript.jscomp.modules.Module;
import com.google.javascript.jscomp.modules.ModuleMap;
import com.google.javascript.jscomp.modules.ModuleMetadataMap.ModuleMetadata;
import com.google.javascript.rhino.Node;
import com.google.javascript.rhino.QualifiedName;
import com.google.javascript.rhino.jstype.JSType;
import java.util.List;
import javax.annotation.Nullable;

/** Centralized location for determining how to rename modules. */
final class ModuleRenaming {

  private ModuleRenaming() {}

  /**
   * The name of the temporary variable created for the default export before globalization of the
   * module.
   */
  static final String DEFAULT_EXPORT_VAR_PREFIX = "$jscompDefaultExport";

  /** Returns the global name of a variable declared in an ES module. */
  static QualifiedName getGlobalNameOfEsModuleLocalVariable(
      ModuleMetadata moduleMetadata, String variableName) {
    return QualifiedName.of(
        variableName + "$$" + getGlobalName(moduleMetadata, /* googNamespace= */ null).join());
  }

  /** Returns the global name of the anonymous default export for the given module. */
  static QualifiedName getGlobalNameOfAnonymousDefaultExport(ModuleMetadata moduleMetadata) {
    return getGlobalNameOfEsModuleLocalVariable(moduleMetadata, DEFAULT_EXPORT_VAR_PREFIX);
  }

  /**
   * @param moduleMetadata the metadata of the module to get the global name of
   * @param googNamespace the Closure namespace that is being referenced fromEsModule this module,
   *     if any
   * @return the global, qualified name to rewrite any references to this module to
   */
  static QualifiedName getGlobalName(
      ModuleMetadata moduleMetadata, @Nullable String googNamespace) {
    return GlobalizedModuleName.create(moduleMetadata, googNamespace, null).aliasName();
  }

  /** Returns the post-transpilation, globalized name of the export. */
  static QualifiedName getGlobalName(Export export) {
    if (export.moduleMetadata().isEs6Module()) {
      if (export.localName().equals(Export.DEFAULT_EXPORT_NAME)) {
        return getGlobalNameOfAnonymousDefaultExport(export.moduleMetadata());
      }
      return getGlobalNameOfEsModuleLocalVariable(export.moduleMetadata(), export.localName());
    }
    return getGlobalName(export.moduleMetadata(), export.closureNamespace())
        .getprop(export.exportName());
  }

  /** Returns the post-transpilation, globalized name of the binding. */
  static QualifiedName getGlobalName(Binding binding) {
    if (binding.isModuleNamespace()) {
      return getGlobalName(binding.metadata(), binding.closureNamespace());
    }
    return getGlobalName(binding.originatingExport());
  }

  private static JSType getNameRootType(String qname, @Nullable TypedScope globalTypedScope) {
    if (globalTypedScope == null) {
      return null;
    }
    String root = NodeUtil.getRootOfQualifiedName(qname);
    return checkNotNull(globalTypedScope.getVar(root), "missing var for %s", root).getType();
  }

  /**
   * Returns the globalized name of a reference to a binding in JS Doc.
   *
   * 
For example:
   *
   * 
   *   // bar
   *   export class Bar {}
   * 
   *
   * 
   *   // foo
   *   import * as bar from 'bar';
   *   export {bar};
   * 
   *
   * 
   *   import * as foo from 'foo';
   *   let /** !foo.bar.Bar *\/ b;
   * 
   *
   * 
Should call this method with the binding for {@code foo} and a list ("bar", "Bar"). In this
   * example any of these properties could also be modules. This method will replace as much as the
   * GETPROP as it can with module exported variables. Meaning in the above example this would
   * return something like "baz$$module$bar", whereas if this method were called for just "foo.bar"
   * it would return "module$bar", as it refers to a module object itself.
   */
  static String getGlobalNameForJsDoc(
      ModuleMap moduleMap, Binding binding, List propertyChain) {
    int prop = 0;

    while (binding.isModuleNamespace()
        && binding.metadata().isEs6Module()
        && prop < propertyChain.size()) {
      String propertyName = propertyChain.get(prop);
      Module m = moduleMap.getModule(binding.metadata().path());
      if (m.namespace().containsKey(propertyName)) {
        binding = m.namespace().get(propertyName);
      } else {
        // This means someone referenced an invalid export on a module object. This should be an
        // error, so just rewrite and let the type checker complain later. It isn't a super clear
        // error, but we're working on type checking modules soon.
        break;
      }
      prop++;
    }

    QualifiedName globalName = getGlobalName(binding);

    while (prop < propertyChain.size()) {
      globalName = globalName.getprop(propertyChain.get(prop++));
    }

    return globalName.join();
  }

  /**
   * Stores a fully qualified globalized name of a module or provide + the type of its root node.
   *
   * 
For goog.provides and legacy goog.modules, the fully qualified name is just the namespace of
   * the module "a.b.c.d". For ES modules, it's deterministically generated based on the module
   * path, e.g. "module$path$to$my$dir". For non-legacy goog.modules, it's deterministically
   * generated based on the module name, e.g. $module$exports$a$b$c$d".
   *
   * 
Used because in some cases, the root of the qualified name will not be present in any scopes
   * until a subsequent run of {@link ClosureRewriteModule}. It's useful to store the type of
   * Closure module exports `module$exports$my$goog$module` separately.
   */
  @AutoValue
  abstract static class GlobalizedModuleName {
    abstract QualifiedName aliasName();
    // The type of the root of `aliasName`, as it may not always exist in the scope yet.
    @Nullable
    abstract JSType rootNameType();

    /** Creates a GETPROP chain with type information representing this name */
    Node toQname(AstFactory astFactory) {
      Node rootName = astFactory.createName(this.aliasName().getRoot(), this.rootNameType());
      if (this.aliasName().isSimple()) {
        return rootName;
      }
      return astFactory.createGetProps(rootName, Iterables.skip(this.aliasName().components(), 1));
    }

    /**
     * Returns a copy of this name with the given {@code property} appended to the {@link
     * #aliasName()}
     */
    GlobalizedModuleName getprop(String property) {
      Preconditions.checkArgument(!property.isEmpty() && !property.contains("."));
      return GlobalizedModuleName.create(aliasName().getprop(property), rootNameType());
    }

    static GlobalizedModuleName create(QualifiedName aliasName, JSType rootNameType) {
      return new AutoValue_ModuleRenaming_GlobalizedModuleName(aliasName, rootNameType);
    }

    /**
     * @param moduleMetadata the metadata of the module to get the global name of
     * @param googNamespace the Closure namespace that is being referenced fromEsModule this module,
     *     if any
     * @param globalTypedScope A global scope expected to contain the types of goog.provided names
     *     and rewritten ES6 module names
     * @return the global, qualified name to rewrite any references to this module to, along with
     *     the type of the root of the module if {@code globalTypedScope} is not null.
     */
    static GlobalizedModuleName create(
        ModuleMetadata moduleMetadata,
        @Nullable String googNamespace,
        @Nullable TypedScope globalTypedScope) {
      checkState(googNamespace == null || moduleMetadata.googNamespaces().contains(googNamespace));
      switch (moduleMetadata.moduleType()) {
        case GOOG_MODULE:
          // The exported type is stored on the MODULE_BODY node.
          Node moduleBody = moduleMetadata.rootNode().getFirstChild();
          return new AutoValue_ModuleRenaming_GlobalizedModuleName(
              QualifiedName.of(ClosureRewriteModule.getBinaryModuleNamespace(googNamespace)),
              moduleBody.getJSType());
        case GOOG_PROVIDE:
        case LEGACY_GOOG_MODULE:
          return new AutoValue_ModuleRenaming_GlobalizedModuleName(
              QualifiedName.of(googNamespace), getNameRootType(googNamespace, globalTypedScope));
        case ES6_MODULE:
        case COMMON_JS:
          return new AutoValue_ModuleRenaming_GlobalizedModuleName(
              QualifiedName.of(moduleMetadata.path().toModuleName()),
              getNameRootType(moduleMetadata.path().toModuleName(), globalTypedScope));
        case SCRIPT:
          // fall through, throw an error
      }
      throw new IllegalStateException("Unexpected module type: " + moduleMetadata.moduleType());
    }
  }
}