Remove more references to NTI from the parts of the compiler.

NOTE: This leave the NTI unit tests in place and functional.

-------------
Created by MOE: https://github.com/google/moe
MOE_MIGRATED_REVID=194712468

src/com/google/javascript/jscomp/AbstractCommandLineRunner.java

@@ -449,7 +449,6 @@ protected void setRunOptions(CompilerOptions options) throws IOException {
     options.processCommonJSModules = config.processCommonJSModules;
     options.moduleRoots = config.moduleRoots;
     options.angularPass = config.angularPass;
-    options.setNewTypeInference(config.useNewTypeInference);
     options.instrumentationTemplateFile = config.instrumentationTemplateFile;
 
     if (config.errorFormat == CommandLineConfig.ErrorFormatOption.JSON) {
@@ -2694,13 +2693,6 @@ public CommandLineConfig setAngularPass(boolean angularPass) {
       return this;
     }
 
-    private boolean useNewTypeInference = false;
-
-    public CommandLineConfig setNewTypeInference(boolean useNewTypeInference) {
-      this.useNewTypeInference = useNewTypeInference;
-      return this;
-    }
-
     private String instrumentationTemplateFile = "";
 
     public CommandLineConfig setInstrumentationTemplateFile(String fileName) {

src/com/google/javascript/jscomp/CommandLineRunner.java

@@ -1622,7 +1622,6 @@ private void initConfigFromFlags(String[] args, PrintStream out, PrintStream err
           .setHideWarningsFor(flags.hideWarningsFor)
           .setAngularPass(flags.angularPass)
           .setInstrumentationTemplateFile(flags.instrumentationFile)
-          .setNewTypeInference(false)
           .setJsonStreamMode(flags.jsonStreamMode)
           .setErrorFormat(flags.errorFormat);
     }

src/com/google/javascript/jscomp/Compiler.java

@@ -419,7 +419,7 @@ protected void reconcileOptionsWithGuards() {
       options.checkTypes = false;
     } else if (!options.checkTypes) {
       // If DiagnosticGroups did not override the plain checkTypes
-      // option, and checkTypes is enabled, then turn off the
+      // option, and checkTypes is disabled, then turn off the
       // parser type warnings.
       options.setWarningLevel(
           DiagnosticGroup.forType(
@@ -1498,7 +1498,7 @@ public TypeIRegistry getTypeIRegistry() {
         // the constructor asks for a type registry, and this may happen before type checking
         // runs. So, in the NONE case, if NTI is enabled, return a new registry, since NTI is
         // the relevant type checker. If NTI is not enabled, return an old registry.
-        return options.getNewTypeInference() ? getGlobalTypeInfo() : getTypeRegistry();
+        return getTypeRegistry();
       case OTI:
         return getTypeRegistry();
       case NTI:

src/com/google/javascript/jscomp/CompilerOptions.java

@@ -222,17 +222,6 @@ boolean shouldPrintExterns() {
    */
   boolean inferTypes;
 
-  private final boolean useNewTypeInference = false;
-
-  /**
-   * Relevant only when {@link #useNewTypeInference} is true, where we normally disable OTI errors.
-   * If you want both NTI and OTI errors in this case, set to true.
-   * E.g. if using using a warnings guard to filter NTI or OTI warnings in new or legacy code,
-   * respectively.
-   * This will be removed when NTI entirely replaces OTI.
-   */
-  boolean reportOTIErrorsUnderNTI = false;
-
   /**
    * Run type checking natively on the subset of ES6 features that we are able to typecheck
    * natively, and then transpile them after NTI.
@@ -2000,11 +1989,7 @@ public boolean getInferTypes() {
     return inferTypes;
   }
 
-  public boolean getNewTypeInference() {
-    return false;
-  }
-
-  /** @deprecated no-op */
+  /** @deprecated This is a no-op. */
   @Deprecated
   public void setNewTypeInference(boolean enable) {
   }
@@ -2013,12 +1998,7 @@ public void setNewTypeInference(boolean enable) {
    * @return true if either typechecker is ON.
    */
   public boolean isTypecheckingEnabled() {
-    return this.checkTypes || this.useNewTypeInference;
-  }
-
-  // Not dead code; used by the open-source users of the compiler.
-  public void setReportOTIErrorsUnderNTI(boolean enable) {
-    this.reportOTIErrorsUnderNTI = enable;
+    return this.checkTypes;
   }
 
   public boolean getTypeCheckEs6Natively() {
@@ -2994,7 +2974,6 @@ public String toString() {
             .add("replaceStringsInputMap", replaceStringsInputMap)
             .add("replaceStringsPlaceholderToken", replaceStringsPlaceholderToken)
             .add("replaceStringsReservedStrings", replaceStringsReservedStrings)
-            .add("reportOTIErrorsUnderNTI", reportOTIErrorsUnderNTI)
             .add("reserveRawExports", reserveRawExports)
             .add("rewriteFunctionExpressions", rewriteFunctionExpressions)
             .add("rewritePolyfills", rewritePolyfills)

src/com/google/javascript/jscomp/CompilerOptionsPreprocessor.java

@@ -55,10 +55,6 @@ static void preprocess(CompilerOptions options) {
           "max_function_size_after_inlining has no effect if inlining is disabled.");
     }
 
-    if (options.getNewTypeInference()) {
-      options.checkGlobalThisLevel = CheckLevel.OFF;
-    }
-
     if (options.dartPass) {
       if (!options.getLanguageOut().toFeatureSet().contains(FeatureSet.ES5)) {
         throw new InvalidOptionsException("Dart requires --language_out=ES5 or higher.");

src/com/google/javascript/jscomp/DefaultPassConfig.java

@@ -220,7 +220,7 @@ protected List<PassFactory> getWhitespaceOnlyPasses() {
     return passes;
   }
 
-  private void addOldTypeCheckerPasses(List<PassFactory> checks, CompilerOptions options) {
+  private void addTypeCheckerPasses(List<PassFactory> checks, CompilerOptions options) {
     if (!options.allowsHotswapReplaceScript()) {
       checks.add(inlineTypeAliases);
     }
@@ -415,25 +415,14 @@ protected List<PassFactory> getChecks() {
     } else {
       checks.add(createEmptyPass(PassNames.BEFORE_TYPE_CHECKING));
 
-      if (options.getNewTypeInference()) {
-        // We will not be updating NTI to understand any more new features,
-        // so transpile those features before running it.
-        if (options.needsTranspilationFrom(ES6)) {
-          TranspilationPasses.addEs6PostTypecheckPasses(checks);
-        }
-        checks.add(symbolTableForNewTypeInference);
-        checks.add(newTypeInference);
-      } else {
-        addOldTypeCheckerPasses(checks, options);
-      }
+      addTypeCheckerPasses(checks, options);
 
       if (options.j2clPassMode.shouldAddJ2clPasses()) {
         checks.add(j2clSourceFileChecker);
       }
 
       if (!options.disables(DiagnosticGroups.CHECK_USELESS_CODE)
-          || (!options.getNewTypeInference()
-              && !options.disables(DiagnosticGroups.MISSING_RETURN))) {
+          || !options.disables(DiagnosticGroups.MISSING_RETURN)) {
         checks.add(checkControlFlow);
       }
 
@@ -444,10 +433,7 @@ protected List<PassFactory> getChecks() {
         checks.add(checkAccessControls);
       }
 
-      if (!options.getNewTypeInference()) {
-        // NTI performs this check already
-        checks.add(checkConsts);
-      }
+      checks.add(checkConsts);
 
       // Analyzer checks must be run after typechecking.
       if (options.enables(DiagnosticGroups.ANALYZER_CHECKS) && options.isTypecheckingEnabled()) {
@@ -494,18 +480,8 @@ protected List<PassFactory> getChecks() {
       }
     }
 
-    // NOTE(dimvar): Tried to move this into the optimizations, but had to back off
-    // because the very first pass, normalization, rewrites the code in a way that
-    // causes loss of type information.
-    // So, I will convert the remaining optimizations to use TypeI and test that only
-    // in unit tests, not full builds. Once all passes are converted, then
-    // drop the OTI-after-NTI altogether.
-    // In addition, I will probably have a local edit of the repo that retains both
-    // types on Nodes, so I can test full builds on my machine. We can't check in such
-    // a change because it would greatly increase memory usage.
-    if (options.getNewTypeInference()) {
-      addOldTypeCheckerPasses(checks, options);
-    }
+
+
 
     // When options.generateExportsAfterTypeChecking is true, run GenerateExports after
     // both type checkers, not just after NTI.
@@ -519,11 +495,7 @@ protected List<PassFactory> getChecks() {
       // At this point all checks have been done.
       // There's no need to complete transpilation if we're only running checks.
 
-      if (!options.getNewTypeInference()) {
-        // Note that TranspilationPasses.addEs6PostTypecheckPasses is really only "post typecheck"
-        // for OTI. The code path for NTI includes an earlier call to addEs6PostTypecheckPasses.
-        TranspilationPasses.addEs6PostTypecheckPasses(checks);
-      }
+      TranspilationPasses.addEs6PostTypecheckPasses(checks);
       TranspilationPasses.addEs6PostCheckPasses(checks);
     }
 
@@ -585,9 +557,7 @@ protected List<PassFactory> getOptimizations() {
       passes.add(j2clUtilGetDefineRewriterPass);
     }
 
-    // TODO(dimvar): convert this pass to use NTI. Low priority since it's
-    // mostly unused. Converting it shouldn't block switching to NTI.
-    if (options.runtimeTypeCheck && !options.getNewTypeInference()) {
+    if (options.runtimeTypeCheck) {
       passes.add(runtimeTypeCheck);
     }
 
@@ -1928,32 +1898,6 @@ protected FeatureSet featureSet() {
         }
       };
 
-  private final PassFactory symbolTableForNewTypeInference =
-      new PassFactory("GlobalTypeInfo", true) {
-        @Override
-        protected CompilerPass create(final AbstractCompiler compiler) {
-          return new GlobalTypeInfoCollector(compiler);
-        }
-
-        @Override
-        protected FeatureSet featureSet() {
-          return FeatureSet.NTI_SUPPORTED;
-        }
-      };
-
-  private final PassFactory newTypeInference =
-      new PassFactory("NewTypeInference", true) {
-        @Override
-        protected CompilerPass create(final AbstractCompiler compiler) {
-          return new NewTypeInference(compiler);
-        }
-
-        @Override
-        protected FeatureSet featureSet() {
-          return FeatureSet.NTI_SUPPORTED;
-        }
-      };
-
   private final HotSwapPassFactory inferJsDocInfo =
       new HotSwapPassFactory("inferJsDocInfo") {
         @Override
@@ -2010,28 +1954,28 @@ protected FeatureSet featureSet() {
       };
 
   /**
-   * Checks possible execution paths of the program for problems: missing return
-   * statements and dead code.
+   * Checks possible execution paths of the program for problems: missing return statements and dead
+   * code.
    */
   private final HotSwapPassFactory checkControlFlow =
       new HotSwapPassFactory("checkControlFlow") {
-    @Override
-    protected HotSwapCompilerPass create(AbstractCompiler compiler) {
-      List<Callback> callbacks = new ArrayList<>();
-      if (!options.disables(DiagnosticGroups.CHECK_USELESS_CODE)) {
-        callbacks.add(new CheckUnreachableCode(compiler));
-      }
-      if (!options.getNewTypeInference() && !options.disables(DiagnosticGroups.MISSING_RETURN)) {
-        callbacks.add(new CheckMissingReturn(compiler));
-      }
-      return combineChecks(compiler, callbacks);
-    }
+        @Override
+        protected HotSwapCompilerPass create(AbstractCompiler compiler) {
+          List<Callback> callbacks = new ArrayList<>();
+          if (!options.disables(DiagnosticGroups.CHECK_USELESS_CODE)) {
+            callbacks.add(new CheckUnreachableCode(compiler));
+          }
+          if (!options.disables(DiagnosticGroups.MISSING_RETURN)) {
+            callbacks.add(new CheckMissingReturn(compiler));
+          }
+          return combineChecks(compiler, callbacks);
+        }
 
-    @Override
-    public FeatureSet featureSet() {
-      return ES8_MODULES;
-    }
-  };
+        @Override
+        public FeatureSet featureSet() {
+          return ES8_MODULES;
+        }
+      };
 
   /** Checks access controls. Depends on type-inference. */
   private final HotSwapPassFactory checkAccessControls =
@@ -2130,17 +2074,6 @@ class GlobalTypeResolver implements HotSwapCompilerPass {
 
     @Override
     public void process(Node externs, Node root) {
-      // If NTI is enabled, erase the NTI types from the AST before adding the old types.
-      if (this.compiler.getOptions().getNewTypeInference()) {
-        NodeTraversal.traversePostOrder(
-            this.compiler,
-            root,
-            (NodeTraversal t, Node n, Node parent) -> {
-              n.setTypeI(null);
-            });
-        this.compiler.clearTypeIRegistry();
-      }
-
       this.compiler.setMostRecentTypechecker(MostRecentTypechecker.OTI);
       if (topScope == null) {
         regenerateGlobalTypedScope(compiler, root.getParent());

src/com/google/javascript/jscomp/Es6ForOfConverter.java

@@ -53,7 +53,7 @@ public final class Es6ForOfConverter implements NodeTraversal.Callback, HotSwapC
   public Es6ForOfConverter(AbstractCompiler compiler) {
     this.compiler = compiler;
     // Only add type information if NTI has been run.
-    this.addTypes = MostRecentTypechecker.NTI.equals(compiler.getMostRecentTypechecker());
+    this.addTypes = MostRecentTypechecker.OTI.equals(compiler.getMostRecentTypechecker());
     this.registry = compiler.getTypeIRegistry();
     this.unknownType = createType(addTypes, registry, JSTypeNative.UNKNOWN_TYPE);
     this.stringType = createType(addTypes, registry, JSTypeNative.STRING_TYPE);

src/com/google/javascript/jscomp/Es7ToEs6Converter.java

@@ -42,7 +42,7 @@ public final class Es7ToEs6Converter implements NodeTraversal.Callback, HotSwapC
 
   public Es7ToEs6Converter(AbstractCompiler compiler) {
     this.compiler = compiler;
-    this.addTypes = MostRecentTypechecker.NTI.equals(compiler.getMostRecentTypechecker());
+    this.addTypes = MostRecentTypechecker.OTI.equals(compiler.getMostRecentTypechecker());
   }
 
   @Override

src/com/google/javascript/jscomp/EsNextToEs8Converter.java

@@ -52,7 +52,7 @@ public final class EsNextToEs8Converter implements NodeTraversal.Callback, HotSw
 
   public EsNextToEs8Converter(AbstractCompiler compiler) {
     this.compiler = compiler;
-    this.addTypes = MostRecentTypechecker.NTI.equals(compiler.getMostRecentTypechecker());
+    this.addTypes = MostRecentTypechecker.OTI.equals(compiler.getMostRecentTypechecker());
   }
 
   @Override

src/com/google/javascript/jscomp/LateEs6ToEs3Converter.java

@@ -64,7 +64,7 @@ public final class LateEs6ToEs3Converter implements NodeTraversal.Callback, HotS
   public LateEs6ToEs3Converter(AbstractCompiler compiler) {
     this.compiler = compiler;
     // Only add type information if NTI has been run.
-    this.addTypes = MostRecentTypechecker.NTI.equals(compiler.getMostRecentTypechecker());
+    this.addTypes = MostRecentTypechecker.OTI.equals(compiler.getMostRecentTypechecker());
     this.registry = compiler.getTypeIRegistry();
     this.unknownType = createType(addTypes, registry, JSTypeNative.UNKNOWN_TYPE);
   }

src/com/google/javascript/jscomp/TranspilationPasses.java

@@ -100,7 +100,7 @@ public static void addEs6PreTypecheckPasses(List<PassFactory> passes, CompilerOp
     passes.add(es6ForOf);
     passes.add(rewriteBlockScopedFunctionDeclaration);
     passes.add(rewriteBlockScopedDeclaration);
-    if (!options.checksOnly || options.getNewTypeInference()) {
+    if (!options.checksOnly) {
       // Don't run these passes in checksOnly mode since all the OTI typechecking & checks passes
       // support the transpiled features.
       passes.add(rewriteBlockScopedDeclaration);

src/com/google/javascript/jscomp/TypedScopeCreator.java

@@ -64,7 +64,6 @@
 import com.google.javascript.jscomp.FunctionTypeBuilder.AstFunctionContents;
 import com.google.javascript.jscomp.NodeTraversal.AbstractScopedCallback;
 import com.google.javascript.jscomp.NodeTraversal.AbstractShallowStatementCallback;
-import com.google.javascript.jscomp.parsing.NullErrorReporter;
 import com.google.javascript.rhino.ErrorReporter;
 import com.google.javascript.rhino.InputId;
 import com.google.javascript.rhino.JSDocInfo;
@@ -169,7 +168,6 @@ final class TypedScopeCreator implements ScopeCreator, StaticSymbolTable<TypedVa
   private final List<FunctionType> delegateProxyCtors = new ArrayList<>();
   private final Map<String, String> delegateCallingConventions = new HashMap<>();
   private final Map<Node, TypedScope> memoized = new LinkedHashMap<>();
-  private final boolean runsAfterNTI;
 
   // Set of functions with non-empty returns, for passing to FunctionTypeBuilder.
   private final Set<Node> functionsWithNonEmptyReturns = new HashSet<>();
@@ -205,22 +203,17 @@ void resolve() {
     this(compiler, compiler.getCodingConvention());
   }
 
-  TypedScopeCreator(AbstractCompiler compiler,
-      CodingConvention codingConvention) {
+  TypedScopeCreator(AbstractCompiler compiler, CodingConvention codingConvention) {
     this.compiler = compiler;
-    this.runsAfterNTI = compiler.getOptions().getNewTypeInference();
     this.validator = compiler.getTypeValidator();
     this.codingConvention = codingConvention;
     this.typeRegistry = compiler.getTypeRegistry();
-    this.typeParsingErrorReporter = this.runsAfterNTI
-        ? NullErrorReporter.forOldRhino() : typeRegistry.getErrorReporter();
+    this.typeParsingErrorReporter = typeRegistry.getErrorReporter();
     this.unknownType = typeRegistry.getNativeObjectType(UNKNOWN_TYPE);
   }
 
   private void report(JSError error) {
-    if (!this.runsAfterNTI || compiler.getOptions().reportOTIErrorsUnderNTI) {
-      compiler.report(error);
-    }
+    compiler.report(error);
   }
 
   @Override

src/com/google/javascript/jscomp/gwt/client/GwtRunner.java

@@ -413,7 +413,6 @@ private static void applyOptionsFromFlags(CompilerOptions options, Flags flags)
     options.setDartPass(flags.dartPass);
     options.setExportLocalPropertyDefinitions(flags.exportLocalPropertyDefinitions);
     options.setGenerateExports(flags.generateExports);
-    options.setNewTypeInference(flags.newTypeInf);
     if (flags.polymerPass) {
       options.setPolymerVersion(1);
     } else if (flags.polymerVersion != null) {