Remove code that requires whole-program compile

lib/src/codegen/js_codegen.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 HashSet, HashMap, SplayTreeSet;
 
 import 'package:analyzer/analyzer.dart' hide ConstantEvaluator;
 import 'package:analyzer/dart/ast/token.dart';
 import 'package:analyzer/dart/element/element.dart';
 import 'package:analyzer/dart/element/visitor.dart';
 import 'package:analyzer/dart/element/type.dart';
 import 'package:analyzer/dart/ast/ast.dart' hide ConstantEvaluator;
 import 'package:analyzer/src/generated/constant.dart';
 //TODO(leafp): Remove deprecated dependency
 //ignore: DEPRECATED_MEMBER_USE
 import 'package:analyzer/src/generated/element.dart'
     show DynamicElementImpl, DynamicTypeImpl, LocalVariableElementImpl;
+// TODO(jmesserly): we can remove this when ResolutionCopier is fixed.
+import 'package:analyzer/src/dart/ast/ast.dart' show FunctionBodyImpl;
 import 'package:analyzer/src/generated/engine.dart' show AnalysisContext;
+import 'package:analyzer/src/generated/parser.dart' show ResolutionCopier;
 import 'package:analyzer/src/generated/resolver.dart' show TypeProvider;
 import 'package:analyzer/src/dart/ast/token.dart'
     show StringToken, Token, TokenType;
 import 'package:analyzer/src/generated/type_system.dart'
     show StrongTypeSystemImpl;
+import 'package:analyzer/src/task/strong/info.dart';
 
 import 'ast_builder.dart' show AstBuilder;
 import 'reify_coercions.dart' show CoercionReifier, Tuple2;
 
 import '../js/js_ast.dart' as JS;
 import '../js/js_ast.dart' show js;
 
 import '../closure/closure_annotator.dart' show ClosureAnnotator;
 import '../compiler.dart'
     show AbstractCompiler, corelibOrder, getCorelibModuleName;
-import '../info.dart';
 import '../options.dart' show CodegenOptions;
 import '../utils.dart';
 
-import 'code_generator.dart';
 import 'js_field_storage.dart';
 import 'js_interop.dart';
 import 'js_names.dart' as JS;
 import 'js_metalet.dart' as JS;
 import 'js_module_item_order.dart';
 import 'js_names.dart';
 import 'js_printer.dart' show writeJsLibrary;
 import 'js_typeref_codegen.dart';
 import 'module_builder.dart';
 import 'nullable_type_inference.dart';
@@ skipping 79 matching lines @@
 
     var context = compiler.context;
     var src = context.sourceFactory.forUri('dart:_interceptors');
     var interceptors = context.computeLibraryElement(src);
     _jsArray = interceptors.getType('JSArray');
     _isDartRuntime = currentLibrary.source.uri.toString() == 'dart:_runtime';
   }
 
   TypeProvider get types => _types;
 
-  JS.Program emitLibrary(LibraryUnit library) {
+  JS.Program emitLibrary(List<CompilationUnit> units) {
+    // Copy the AST before modifying it.
+    units = units.map(_cloneCompilationUnit).toList();
+
     // Modify the AST to make coercions explicit.
-    new CoercionReifier(library, rules).reify();
+    new CoercionReifier(rules).reify(units);
 
-    library.library.directives.forEach(_visit);
-
-    var units = library.partsThenLibrary;
+    units.last.directives.forEach(_visit);
 
     // Rather than directly visit declarations, we instead use [_loader] to
     // visit them. It has the ability to sort elements on demand, so
     // dependencies between top level items are handled with a minimal
     // reordering of the user's input code. The loader will call back into
     // this visitor via [_emitModuleItem] when it's ready to visit the item
     // for real.
     _loader.collectElements(currentLibrary, units);
 
     // TODO(jmesserly): ideally we could do this at a smaller granularity.
     // We'll need to be consistent about when we're generating functions, and
     // only run this on the outermost function.
     inferNullableTypesInLibrary(units);
 
-    _constField = new ConstFieldVisitor(types, library.library.element.source);
+    _constField = new ConstFieldVisitor(types, currentLibrary.source);
 
     for (var unit in units) {
       for (var decl in unit.declarations) {
         if (decl is TopLevelVariableDeclaration) {
           visitTopLevelVariableDeclaration(decl);
         } else {
           _loader.loadDeclaration(decl, decl.element);
         }
       }
     }
@@ skipping 3583 matching lines @@
           _addExtensionTypes(libraryUri);
         }
         _pendingLibraries.clear();
         return _extensionTypes.contains(element);
       }
     }
     return false;
   }
 }
 
-class JSGenerator extends CodeGenerator {
+class JSGenerator {
+  final AbstractCompiler compiler;
   final ExtensionTypeSet _extensionTypes;
   final TypeProvider _types;
 
   JSGenerator(AbstractCompiler compiler)
-      : _types = compiler.context.typeProvider,
-        _extensionTypes = new ExtensionTypeSet(compiler),
-        super(compiler) {
+      : compiler = compiler,
+        _types = compiler.context.typeProvider,
+        _extensionTypes = new ExtensionTypeSet(compiler) {
     // TODO(vsm): Eventually, we want to make this extensible - i.e., find
     // annotations in user code as well.  It would need to be summarized in
     // the element model - not searched this way on every compile.  To make this
     // a little more efficient now, we do this in two phases.
 
     // First, core types:
     _extensionTypes._addExtensionTypes('dart:_interceptors');
     _extensionTypes._addExtensionTypes('dart:_native_typed_data');
     // TODO(vsm): If we're analyzing against the main SDK, those
     // types are not explicitly annotated.
@@ skipping 10 matching lines @@
 
     // Second, html types - these are only searched if we use dart:html, etc.:
     _extensionTypes._addPendingExtensionTypes('dart:html');
     _extensionTypes._addPendingExtensionTypes('dart:indexed_db');
     _extensionTypes._addPendingExtensionTypes('dart:svg');
     _extensionTypes._addPendingExtensionTypes('dart:web_audio');
     _extensionTypes._addPendingExtensionTypes('dart:web_gl');
     _extensionTypes._addPendingExtensionTypes('dart:web_sql');
   }
 
-  String generateLibrary(LibraryUnit unit) {
-    // Clone the AST first, so we can mutate it.
-    unit = unit.clone();
-    var library = unit.library.element.library;
-    var fields = findFieldsNeedingStorage(unit, _extensionTypes);
+  void generateLibrary(List<CompilationUnit> units) {
+    var library = units.first.element.library;
+    var fields =
+        findFieldsNeedingStorage(units.map((c) => c.element), _extensionTypes);
     var rules = new StrongTypeSystemImpl();
     var codegen =
         new JSCodegenVisitor(compiler, rules, library, _extensionTypes, fields);
-    var module = codegen.emitLibrary(unit);
+    var module = codegen.emitLibrary(units);
     var out = compiler.getOutputPath(library.source.uri);
-    var flags = compiler.options;
-    var serverUri = flags.serverMode
-        ? Uri.parse('http://${flags.host}:${flags.port}/')
-        : null;
-    return writeJsLibrary(module, out, compiler.inputBaseDir, serverUri,
+    var options = compiler.options.codegenOptions;
+    writeJsLibrary(module, out, compiler.inputBaseDir,
         emitTypes: options.closure,
         emitSourceMaps: options.emitSourceMaps,
         fileSystem: compiler.fileSystem);
   }
 }
 
 /// 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(LibraryElement library) => canonicalLibraryName(library);
@@ skipping 11 matching lines @@
 
 /// A special kind of element created by the compiler, signifying a temporary
 /// variable. These objects use instance equality, and should be shared
 /// everywhere in the tree where they are treated as the same variable.
 class TemporaryVariableElement extends LocalVariableElementImpl {
   TemporaryVariableElement.forNode(Identifier name) : super.forNode(name);
 
   int get hashCode => identityHashCode(this);
   bool operator ==(Object other) => identical(this, other);
 }
+
+CompilationUnit _cloneCompilationUnit(CompilationUnit unit) {
+  var result = new _TreeCloner().visitCompilationUnit(unit);
+  ResolutionCopier.copyResolutionData(unit, result);
+  return result;
+}
+
+class _TreeCloner extends AstCloner {
+  void _cloneProperties(AstNode clone, AstNode node) {
+    if (clone != null) {
+      CoercionInfo.set(clone, CoercionInfo.get(node));
+      DynamicInvoke.set(clone, DynamicInvoke.get(node));
+    }
+  }
+
+  @override
+  AstNode cloneNode(AstNode node) {
+    var clone = super.cloneNode(node);
+    _cloneProperties(clone, node);
+    return clone;
+  }
+
+  @override
+  List cloneNodeList(List list) {
+    var clone = super.cloneNodeList(list);
+    for (int i = 0, len = list.length; i < len; i++) {
+      _cloneProperties(clone[i], list[i]);
+    }
+    return clone;
+  }
+
+  // TODO(jmesserly): ResolutionCopier is not copying this yet.
+  @override
+  BlockFunctionBody visitBlockFunctionBody(BlockFunctionBody node) {
+    var clone = super.visitBlockFunctionBody(node);
+    (clone as FunctionBodyImpl).localVariableInfo =
+        (node as FunctionBodyImpl).localVariableInfo;
+    return clone;
+  }
+
+  @override
+  ExpressionFunctionBody visitExpressionFunctionBody(
+      ExpressionFunctionBody node) {
+    var clone = super.visitExpressionFunctionBody(node);
+    (clone as FunctionBodyImpl).localVariableInfo =
+        (node as FunctionBodyImpl).localVariableInfo;
+    return clone;
+  }
+}