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:async';
 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, TypeProviderImpl;
 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';
@@ skipping 15 matching lines @@
 import 'js_names.dart' as JS;
 import 'js_typeref_codegen.dart' show JsTypeRefCodegen;
 import 'module_builder.dart' show pathToJSIdentifier;
 import 'nullable_type_inference.dart' show NullableTypeInference;
 import 'reify_coercions.dart' show CoercionReifier;
 import 'side_effect_analysis.dart' show ConstFieldVisitor, isStateless;
 import 'type_utilities.dart';
 
 class CodeGenerator extends GeneralizingAstVisitor
     with ClosureAnnotator, JsTypeRefCodegen, NullableTypeInference {
-  final AnalysisContext context;
+  final AnalysisDriver driver;
   final SummaryDataStore summaryData;
 
   final CompilerOptions options;
-  final StrongTypeSystemImpl rules;
+  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.
   final _libraries = new Map<LibraryElement, JS.Identifier>();
 
   /// Imported libraries, and the temporaries used to refer to them.
   final _imports = new Map<LibraryElement, JS.TemporaryId>();
@@ skipping 27 matching lines @@
 
   JS.Identifier _extensionSymbolsModule;
   JS.Identifier _runtimeModule;
   final namedArgumentTemp = new JS.TemporaryId('opts');
 
   final _hasDeferredSupertype = new HashSet<ClassElement>();
 
   final _eagerTopLevelFields = new HashSet<Element>.identity();
 
   /// The  type provider from the current Analysis [context].
-  final TypeProvider types;
+  TypeProvider types;
 
-  final LibraryElement dartCoreLibrary;
-  final LibraryElement dartJSLibrary;
+  LibraryElement dartCoreLibrary;
+  LibraryElement dartJSLibrary;
 
   /// The dart:async `StreamIterator<>` type.
-  final InterfaceType _asyncStreamIterator;
+  InterfaceType _asyncStreamIterator;
 
   /// The dart:_interceptors JSArray element.
-  final ClassElement _jsArray;
+  ClassElement _jsArray;
 
-  final ClassElement boolClass;
-  final ClassElement intClass;
-  final ClassElement interceptorClass;
-  final ClassElement nullClass;
-  final ClassElement numClass;
-  final ClassElement objectClass;
-  final ClassElement stringClass;
-  final ClassElement functionClass;
-  final ClassElement privateSymbolClass;
+  ClassElement boolClass;
+  ClassElement intClass;
+  ClassElement interceptorClass;
+  ClassElement nullClass;
+  ClassElement numClass;
+  ClassElement objectClass;
+  ClassElement stringClass;
+  ClassElement functionClass;
+  ClassElement privateSymbolClass;
 
   ConstFieldVisitor _constants;
 
   /// The current function body being compiled.
   FunctionBody _currentFunction;
 
   /// Helper class for emitting elements in the proper order to allow
   /// JS to load the module.
   ElementLoader _loader;
 
   BuildUnit _buildUnit;
 
   String _libraryRoot;
 
   bool _superAllowed = true;
 
   List<JS.TemporaryId> _superHelperSymbols = <JS.TemporaryId>[];
   List<JS.Method> _superHelpers = <JS.Method>[];
 
   List<TypeParameterType> _typeParamInConst = null;
 
   /// Whether we are currently generating code for the body of a `JS()` call.
   bool _isInForeignJS = false;
 
   /// 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;
 
-  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');
+  CodeGenerator._(
+      this.driver, this.summaryData, this.options, this._extensionTypes);
+
+  static Future<CodeGenerator> create(
+      AnalysisDriver driver,
+      SummaryDataStore summaryData,
+      CompilerOptions options,
+      ExtensionTypeSet extensionTypes) async {
+    CodeGenerator codeGenerator =
+        new CodeGenerator._(driver, summaryData, options, extensionTypes);
+    await codeGenerator._initialize();
+    return codeGenerator;
+  }
+
+  Future<Null> _initialize() async {
+    var coreLibrary = await _computeLibraryByUri('dart:core');
+    var asyncLibrary = await _computeLibraryByUri('dart:async');
+
+    types = new TypeProviderImpl(coreLibrary, asyncLibrary);
+    rules = new StrongTypeSystemImpl(types);
+
+    _asyncStreamIterator = asyncLibrary.getType('StreamIterator').type;
+
+    var interceptorsLibrary = await _computeLibraryByUri('dart:_interceptors');
+    _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');
+
+    var internalLibrary = await _computeLibraryByUri('dart:_internal');
+    privateSymbolClass = internalLibrary.getType('PrivateSymbol');
+
+    dartJSLibrary = await _computeLibraryByUri('dart:js');
+  }
 
   LibraryElement get currentLibrary => _loader.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,
       List<String> errors) {
     _buildUnit = unit;
     _libraryRoot = _buildUnit.libraryRoot;
     if (!_libraryRoot.endsWith(separator)) {
       _libraryRoot += separator;
     }
 
     var module = _emitModule(compilationUnits, unit.name);
     var dartApiSummary = _summarizeModule(compilationUnits);
 
     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 (_isDartRuntime(library)) {
         items.add(new JS.ExportDeclaration(js
             .call('const # = Object.create(null)', [_extensionSymbolsModule])));
       }
     }
 
     // Collect all Element -> Node mappings, in case we need to forward declare
     // any nodes.
-    var nodes = new HashMap<Element, AstNode>.identity();
+    var nodes = new HashMap<Element, AstNode>();
     var sdkBootstrappingFns = new List<FunctionElement>();
     for (var unit in compilationUnits) {
       if (_isDartRuntime(
           resolutionMap.elementDeclaredByCompilationUnit(unit).library)) {
         sdkBootstrappingFns.addAll(
             resolutionMap.elementDeclaredByCompilationUnit(unit).functions);
       }
       _collectElements(unit, nodes);
     }
     _loader = new ElementLoader(nodes);
     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);
 
     // Emit SDK bootstrapping functions first, if any.
     sdkBootstrappingFns.forEach(_emitDeclaration);
@@ skipping 1549 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 4036 matching lines @@
         return whitelisted.contains(name);
       }
     }
 
     // Dynamic calls are less risky so there is no need to whitelist at the
     // method level.
     if (isCall && _uncheckedWhitelistCalls.contains(filename)) return true;
 
     return path.endsWith(".template.dart");
   }
+
+  Future<LibraryElement> _computeLibraryByUri(String libraryUri) async {
+    return await driver.resynthesizeLibrary(libraryUri);
+  }
 }
 
 /// Choose a canonical name from the [library] element.
 ///
 /// This never uses the library's name (the identifier in the `library`
 /// declaration) as it doesn't have any meaningful rules enforced.
 String jsLibraryName(String libraryRoot, LibraryElement library) {
   var uri = library.source.uri;
   if (uri.scheme == 'dart') {
     return uri.path;
@@ skipping 103 matching lines @@
   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;
 }