com.google.javascript.jscomp.modules.NonEsModuleProcessor Maven / Gradle / Ivy

Go to download

Show more of this group Show more artifacts with this name
Show all versions of closure-compiler-linter Show documentation

Closure Compiler is a JavaScript optimizing compiler. It parses your JavaScript, analyzes it, removes dead code and rewrites and minimizes what's left. It also checks syntax, variable references, and types, and warns about common JavaScript pitfalls. It is used in many of Google's JavaScript apps, including Gmail, Google Web Search, Google Maps, and Google Docs. This binary checks for style issues such as incorrect or missing JSDoc usage, and missing goog.require() statements. It does not do more advanced checks such as typechecking.

There is a newer version: v20200830

Show newest version

/*
 * 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.modules;

import com.google.common.collect.ImmutableMap;
import com.google.common.collect.ImmutableSet;
import com.google.javascript.jscomp.deps.ModuleLoader.ModulePath;
import com.google.javascript.jscomp.modules.ModuleMapCreator.ModuleProcessor;
import com.google.javascript.jscomp.modules.ModuleMetadataMap.ModuleMetadata;
import com.google.javascript.rhino.Node;
import java.util.Set;
import javax.annotation.Nullable;

/**
 * Catch all module processor for non-ES modules that doesn't do any scanning of exports but instead
 * will always treat every name as `munged.name`.
 */
// TODO(johnplaisted): It may not be too hard to actually scan these modules and figure out their
// exported keys. At least, assuming we're rigid with what we allow (no dynamic exports).
final class NonEsModuleProcessor implements ModuleProcessor {

  private static class NonEsModule extends UnresolvedModule {

    private final ModuleMetadata metadata;
    private final ModulePath path;
    private final Node scriptNode;

    NonEsModule(ModuleMetadata metadata, ModulePath path, Node scriptNode) {
      this.metadata = metadata;
      this.path = path;
      this.scriptNode = scriptNode;
    }

    @Nullable
    @Override
    public ResolveExportResult resolveExport(
        ModuleRequestResolver moduleRequestResolver, String exportName) {
      throw new UnsupportedOperationException();
    }

    @Nullable
    @Override
    public ResolveExportResult resolveExport(
        ModuleRequestResolver moduleRequestResolver,
        @Nullable String moduleSpecifier,
        String exportName,
        Set resolveSet,
        Set exportStarSet) {
      String namespace = null;
      if (moduleSpecifier != null && GoogEsImports.isGoogImportSpecifier(moduleSpecifier)) {
        namespace = GoogEsImports.getClosureIdFromGoogImportSpecifier(moduleSpecifier);
      }
      return ResolveExportResult.of(
          Binding.from(
              Export.builder()
                  .localName(exportName)
                  .moduleMetadata(metadata)
                  .modulePath(path)
                  .closureNamespace(namespace)
                  .build(),
              scriptNode));
    }

    @Override
    void reset() {}

    @Override
    public Module resolve(
        ModuleRequestResolver moduleRequestResolver, @Nullable String moduleSpecifier) {
      String namespace = null;
      if (moduleSpecifier != null && GoogEsImports.isGoogImportSpecifier(moduleSpecifier)) {
        namespace = GoogEsImports.getClosureIdFromGoogImportSpecifier(moduleSpecifier);
      }
      return Module.builder()
          .path(path)
          .metadata(metadata)
          .namespace(ImmutableMap.of())
          .boundNames(ImmutableMap.of())
          .localNameToLocalExport(ImmutableMap.of())
          .closureNamespace(namespace)
          .unresolvedModule(this)
          .build();
    }

    @Override
    public boolean isEsModule() {
      return false;
    }

    @Override
    public ImmutableSet getExportedNames(ModuleRequestResolver moduleRequestResolver) {
      throw new UnsupportedOperationException();
    }

    @Override
    public ImmutableSet getExportedNames(
        ModuleRequestResolver moduleRequestResolver, Set visited) {
      throw new UnsupportedOperationException();
    }
  }

  @Override
  public UnresolvedModule process(ModuleMetadata metadata, ModulePath path, Node script) {
    return new NonEsModule(metadata, path, script);
  }
}