Migrate DDC to the new analysis driver.

pkg/dev_compiler/lib/src/compiler/code_generator.dart

 // Copyright (c) 2015, the Dart project authors.  Please see the AUTHORS file
 
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 import 'dart:collection' show HashMap, HashSet;
 import 'dart:math' show min, max;
 
 import 'package:analyzer/analyzer.dart' hide ConstantEvaluator;
 import 'package:analyzer/dart/ast/ast.dart';
 import 'package:analyzer/dart/ast/standard_ast_factory.dart';
 import 'package:analyzer/dart/ast/token.dart' show Token, TokenType;
 import 'package:analyzer/dart/ast/standard_resolution_map.dart';
 import 'package:analyzer/dart/element/element.dart';
 import 'package:analyzer/dart/element/type.dart';
+import 'package:analyzer/src/dart/analysis/driver.dart';
 import 'package:analyzer/src/dart/ast/token.dart' show StringToken;
 import 'package:analyzer/src/dart/element/element.dart'
     show FieldElementImpl, LocalVariableElementImpl;
 import 'package:analyzer/src/dart/element/type.dart' show DynamicTypeImpl;
 import 'package:analyzer/src/dart/sdk/sdk.dart';
-import 'package:analyzer/src/generated/engine.dart' show AnalysisContext;
 import 'package:analyzer/src/generated/resolver.dart'
-    show TypeProvider, NamespaceBuilder;
+    show NamespaceBuilder, TypeProvider;
 import 'package:analyzer/src/generated/type_system.dart'
     show StrongTypeSystemImpl;
 import 'package:analyzer/src/summary/idl.dart' show UnlinkedUnit;
 import 'package:analyzer/src/summary/link.dart' as summary_link;
 import 'package:analyzer/src/summary/package_bundle_reader.dart';
 import 'package:analyzer/src/summary/summarize_ast.dart'
     show serializeAstUnlinked;
 import 'package:analyzer/src/summary/summarize_elements.dart'
     show PackageBundleAssembler;
 import 'package:analyzer/src/summary/summary_sdk.dart';
 import 'package:analyzer/src/task/strong/ast_properties.dart'
     show isDynamicInvoke, setIsDynamicInvoke, getImplicitAssignmentCast;
+import 'package:meta/meta.dart';
 import 'package:path/path.dart' show isWithin, relative, separator;
 
 import '../closure/closure_annotator.dart' show ClosureAnnotator;
 import '../js_ast/js_ast.dart' as JS;
 import '../js_ast/js_ast.dart' show js;
 import 'ast_builder.dart' show AstBuilder;
 import 'compiler.dart' show BuildUnit, CompilerOptions, JSModuleFile;
 import 'element_helpers.dart';
 import 'extension_types.dart' show ExtensionTypeSet;
 import 'js_interop.dart';
@@ skipping 17 matching lines @@
 /// Dart code, whenever this is possible to do in the generated code.
 //
 // TODO(jmesserly): we should use separate visitors for statements and
 // expressions. Declarations are handled directly, and many minor component
 // AST nodes aren't visited, so the visitor pattern isn't helping except for
 // expressions (which result in JS.Expression) and statements
 // (which result in (JS.Statement).
 class CodeGenerator extends Object
     with ClosureAnnotator, JsTypeRefCodegen, NullableTypeInference
     implements AstVisitor<JS.Node> {
-  final AnalysisContext context;
+  final AnalysisDriver driver;
   final SummaryDataStore summaryData;
 
   final CompilerOptions options;
   final StrongTypeSystemImpl rules;
 
   /// The set of libraries we are currently compiling, and the temporaries used
   /// to refer to them.
   ///
   /// We sometimes special case codegen for a single library, as it simplifies
   /// name scoping requirements.
@@ skipping 32 matching lines @@
       new HashMap<LibraryElement, HashMap<String, JS.TemporaryId>>();
   final _initializingFormalTemps =
       new HashMap<ParameterElement, JS.TemporaryId>();
 
   JS.Identifier _extensionSymbolsModule;
   JS.Identifier _runtimeModule;
   final namedArgumentTemp = new JS.TemporaryId('opts');
 
   final _hasDeferredSupertype = new HashSet<ClassElement>();
 
-  /// The  type provider from the current Analysis [context].
+  /// The type provider for the SDK.
   final TypeProvider types;
 
   final LibraryElement dartCoreLibrary;
   final LibraryElement dartJSLibrary;
 
   /// The dart:async `StreamIterator<>` type.
   final InterfaceType _asyncStreamIterator;
 
   /// The dart:_interceptors JSArray element.
   final ClassElement _jsArray;
@@ skipping 48 matching lines @@
 
   /// Information about virtual and overridden fields/getters/setters in the
   /// class we're currently compiling, or `null` if we aren't compiling a class.
   ClassPropertyModel _classProperties;
 
   /// Information about virtual fields for all libraries in the current build
   /// unit.
   final virtualFields = new VirtualFieldModel();
 
   CodeGenerator(
-      AnalysisContext c, this.summaryData, this.options, this._extensionTypes)
-      : context = c,
-        rules = new StrongTypeSystemImpl(c.typeProvider),
-        types = c.typeProvider,
-        _asyncStreamIterator =
-            _getLibrary(c, 'dart:async').getType('StreamIterator').type,
-        _jsArray = _getLibrary(c, 'dart:_interceptors').getType('JSArray'),
-        interceptorClass =
-            _getLibrary(c, 'dart:_interceptors').getType('Interceptor'),
-        dartCoreLibrary = _getLibrary(c, 'dart:core'),
-        boolClass = _getLibrary(c, 'dart:core').getType('bool'),
-        intClass = _getLibrary(c, 'dart:core').getType('int'),
-        numClass = _getLibrary(c, 'dart:core').getType('num'),
-        nullClass = _getLibrary(c, 'dart:core').getType('Null'),
-        objectClass = _getLibrary(c, 'dart:core').getType('Object'),
-        stringClass = _getLibrary(c, 'dart:core').getType('String'),
-        functionClass = _getLibrary(c, 'dart:core').getType('Function'),
-        privateSymbolClass =
-            _getLibrary(c, 'dart:_internal').getType('PrivateSymbol'),
-        dartJSLibrary = _getLibrary(c, 'dart:js');
+      this.driver, this.summaryData, this.options, this._extensionTypes,
+      {@required this.types,
+      @required LibraryElement coreLibrary,
+      @required LibraryElement asyncLibrary,
+      @required LibraryElement interceptorsLibrary,
+      @required LibraryElement internalLibrary,
+      @required LibraryElement jsLibrary})
+      : rules = new StrongTypeSystemImpl(types),
+        _asyncStreamIterator = asyncLibrary.getType('StreamIterator').type,
+        _jsArray = interceptorsLibrary.getType('JSArray'),
+        interceptorClass = interceptorsLibrary.getType('Interceptor'),
+        dartCoreLibrary = coreLibrary,
+        boolClass = coreLibrary.getType('bool'),
+        intClass = coreLibrary.getType('int'),
+        numClass = coreLibrary.getType('num'),
+        nullClass = coreLibrary.getType('Null'),
+        objectClass = coreLibrary.getType('Object'),
+        stringClass = coreLibrary.getType('String'),
+        functionClass = coreLibrary.getType('Function'),
+        privateSymbolClass = internalLibrary.getType('PrivateSymbol'),
+        dartJSLibrary = jsLibrary;
 
   Element get currentElement => _currentElements.last;
 
   LibraryElement get currentLibrary => currentElement.library;
 
   /// The main entry point to JavaScript code generation.
   ///
   /// Takes the metadata for the build unit, as well as resolved trees and
   /// errors, and computes the output module code and optionally the source map.
   JSModuleFile compile(BuildUnit unit, List<CompilationUnit> compilationUnits,
@@ skipping 10 matching lines @@
     return new JSModuleFile(unit.name, errors, options, module, dartApiSummary);
   }
 
   List<int> _summarizeModule(List<CompilationUnit> units) {
     if (!options.summarizeApi) return null;
 
     if (!units.any((u) => resolutionMap
         .elementDeclaredByCompilationUnit(u)
         .librarySource
         .isInSystemLibrary)) {
-      var sdk = context.sourceFactory.dartSdk;
+      var sdk = driver.sourceFactory.dartSdk;
       summaryData.addBundle(
           null,
           sdk is SummaryBasedDartSdk
               ? sdk.bundle
               : (sdk as FolderBasedDartSdk).getSummarySdkBundle(true));
     }
 
     var assembler = new PackageBundleAssembler();
     assembler.recordDependencies(summaryData);
 
     var uriToUnit = new Map<String, UnlinkedUnit>.fromIterable(units,
         key: (u) => u.element.source.uri.toString(),
         value: (unit) {
           var unlinked = serializeAstUnlinked(unit);
           assembler.addUnlinkedUnit(unit.element.source, unlinked);
           return unlinked;
         });
 
     summary_link
         .link(
             uriToUnit.keys.toSet(),
             (uri) => summaryData.linkedMap[uri],
             (uri) => summaryData.unlinkedMap[uri] ?? uriToUnit[uri],
-            context.declaredVariables.get,
+            driver.declaredVariables.get,
             true)
         .forEach(assembler.addLinkedLibrary);
 
     var bundle = assembler.assemble();
     // Preserve only API-level information in the summary.
     bundle.flushInformative();
     return bundle.toBuffer();
   }
 
   JS.Program _emitModule(List<CompilationUnit> compilationUnits, String name) {
@@ skipping 34 matching lines @@
       // dart:_runtime has a magic module that holds extension method symbols.
       // TODO(jmesserly): find a cleaner design for this.
       if (isSdkInternalRuntime(library)) {
         items.add(new JS.ExportDeclaration(js
             .call('const # = Object.create(null)', [_extensionSymbolsModule])));
       }
     }
 
     // Collect all class/type Element -> Node mappings
     // in case we need to forward declare any classes.
-    _declarationNodes = new HashMap<TypeDefiningElement, AstNode>.identity();
+    _declarationNodes = new HashMap<TypeDefiningElement, AstNode>();
     for (var unit in compilationUnits) {
       for (var declaration in unit.declarations) {
         var element = declaration.element;
         if (element is TypeDefiningElement) {
           _declarationNodes[element] = declaration;
         }
       }
     }
     if (compilationUnits.isNotEmpty) {
-      _constants = new ConstFieldVisitor(context,
+      _constants = new ConstFieldVisitor(types, driver.declaredVariables,
           dummySource: resolutionMap
               .elementDeclaredByCompilationUnit(compilationUnits.first)
               .source);
     }
 
     // Add implicit dart:core dependency so it is first.
     emitLibraryName(dartCoreLibrary);
 
     // Visit each compilation unit and emit its code.
     //
@@ skipping 197 matching lines @@
 
     var last = _currentElements.removeLast();
     assert(identical(e, last));
   }
 
   /// Start generating top-level code for the element [e].
   ///
   /// Subsequent [emitDeclaration] calls will cause those elements to be
   /// generated before this one, until [finishTopLevel] is called.
   void _startTopLevelCodeForClass(TypeDefiningElement e) {
-    assert(identical(e, currentElement));
+    assert(e == currentElement);
     _topLevelElements.add(e);
   }
 
   /// Finishes the top-level code for the element [e].
   void _finishTopLevelCodeForClass(TypeDefiningElement e) {
     var last = _topLevelElements.removeLast();
     assert(identical(e, last));
   }
 
   /// To emit top-level module items, we sometimes need to reorder them.
   ///
   /// This function takes care of that, and also detects cases where reordering
   /// failed, and we need to resort to lazy loading, by marking the element as
   /// lazy. All elements need to be aware of this possibility and generate code
   /// accordingly.
   ///
   /// If we are not emitting top-level code, this does nothing, because all
   /// declarations are assumed to be available before we start execution.
   /// See [startTopLevel].
   void _declareBeforeUse(TypeDefiningElement e) {
     if (e == null) return;
 
     var topLevel = _topLevelElements;
-    if (topLevel.isNotEmpty && identical(currentElement, topLevel.last)) {
+    if (topLevel.isNotEmpty && currentElement == topLevel.last) {
       // If the item is from our library, try to emit it now.
       _emitTypeDeclaration(e);
     }
   }
 
   @override
   visitCompilationUnit(CompilationUnit unit) {
     // NOTE: this method isn't the right place to initialize
     // per-compilation-unit state. Declarations can be visited out of order,
     // this is only to catch things that haven't been emitted yet.
@@ skipping 1326 matching lines @@
         lookup = classElem.type.lookUpInheritedGetter;
         tMember = node.isStatic ? tStaticGetters : tInstanceGetters;
       } else if (node.isSetter) {
         elementToType = (ExecutableElement element) => element.type;
         getOverride = classElem.lookUpInheritedConcreteSetter;
         lookup = classElem.type.lookUpInheritedSetter;
         tMember = node.isStatic ? tStaticSetters : tInstanceSetters;
       } else {
         // Method
         // Swap in "Object" for parameter types that are covariant overrides.
-        var objectType = context.typeProvider.objectType;
+        var objectType = types.objectType;
         elementToType =
             (MethodElement element) => element.getReifiedType(objectType);
         getOverride = classElem.lookUpInheritedConcreteMethod;
         lookup = classElem.type.lookUpInheritedMethod;
         tMember = node.isStatic ? tStaticMethods : tInstanceMethods;
       }
 
       DartType reifiedType = elementToType(element);
       // Don't add redundant signatures for inherited methods whose signature
       // did not change.  If we are not overriding, or if the thing we are
@@ skipping 2392 matching lines @@
   int _asIntInRange(Expression expr, int low, int high) {
     expr = expr.unParenthesized;
     if (expr is IntegerLiteral) {
       if (expr.value >= low && expr.value <= high) return expr.value;
       return null;
     }
     int finishIdentifier(SimpleIdentifier identifier) {
       Element staticElement = identifier.staticElement;
       if (staticElement is PropertyAccessorElement && staticElement.isGetter) {
         PropertyInducingElement variable = staticElement.variable;
-        int value = variable?.computeConstantValue()?.toIntValue();
+        int value = variable?.constantValue?.toIntValue();
         if (value != null && value >= low && value <= high) return value;
       }
       return null;
     }
 
     if (expr is SimpleIdentifier) {
       return finishIdentifier(expr);
     } else if (expr is PrefixedIdentifier && !expr.isDeferred) {
       return finishIdentifier(expr.identifier);
     }
@@ skipping 1560 matching lines @@
       : super.forNode(name);
 
   int get hashCode => identityHashCode(this);
 
   bool operator ==(Object other) => identical(this, other);
 }
 
 bool isLibraryPrefix(Expression node) =>
     node is SimpleIdentifier && node.staticElement is PrefixElement;
 
-LibraryElement _getLibrary(AnalysisContext c, String uri) =>
-    c.computeLibraryElement(c.sourceFactory.forUri(uri));
-
 /// Returns `true` if [target] is a prefix for a deferred library and [name]
 /// is "loadLibrary".
 ///
 /// If so, the expression should be compiled to call the runtime's
 /// "loadLibrary" helper function.
 bool _isDeferredLoadLibrary(Expression target, SimpleIdentifier name) {
   if (name.name != "loadLibrary") return false;
 
   if (target is! SimpleIdentifier) return false;
   var targetIdentifier = target as SimpleIdentifier;
 
   if (targetIdentifier.staticElement is! PrefixElement) return false;
   var prefix = targetIdentifier.staticElement as PrefixElement;
 
   // The library the prefix is referring to must come from a deferred import.
   var containingLibrary = resolutionMap
       .elementDeclaredByCompilationUnit(target.root as CompilationUnit)
       .library;
   var imports = containingLibrary.getImportsWithPrefix(prefix);
   return imports.length == 1 && imports[0].isDeferred;
 }