Roll sdk dependency to 34357cdad108dcba734949bd13bd28c76ea285e0

pkg/fletchc/lib/incremental/library_updater.dart

 // Copyright (c) 2014, 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.
 
 library fletchc_incremental.library_updater;
 
 import 'dart:async' show
     Future;
 
 import 'package:compiler/compiler_new.dart' show
     CompilerDiagnostics,
     Diagnostic;
 
 import 'package:compiler/compiler.dart' as api;
 
-import 'package:compiler/src/dart2jslib.dart' show
-    Compiler,
-    EnqueueTask,
-    MessageKind,
+import 'package:compiler/src/compiler.dart' show
+    Compiler;
+
+import 'package:compiler/src/enqueue.dart' show
+    EnqueueTask;
+
+import 'package:compiler/src/diagnostics/messages.dart' show
+    MessageKind;
+
+import 'package:compiler/src/script.dart' show
     Script;
 
 import 'package:compiler/src/elements/elements.dart' show
     AstElement,
     ClassElement,
     CompilationUnitElement,
     Element,
     FieldElement,
     FunctionElement,
     LibraryElement,
     STATE_NOT_STARTED,
     ScopeContainerElement,
     TypeDeclarationElement;
 
-import 'package:compiler/src/scanner/scannerlib.dart' show
-    EOF_TOKEN,
-    Listener,
-    NodeListener,
-    Parser,
+import 'package:compiler/src/tokens/token_constants.dart' show
+    EOF_TOKEN;
+
+import 'package:compiler/src/tokens/token.dart' show
+    Token;
+
+import 'package:compiler/src/parser/partial_elements.dart' show
     PartialClassElement,
     PartialElement,
     PartialFieldList,
-    PartialFunctionElement,
-    Scanner,
-    Token;
+    PartialFunctionElement;
+
+import 'package:compiler/src/scanner/scanner.dart' show
+    Scanner;
+
+import 'package:compiler/src/parser/parser.dart' show
+    Parser;
+
+import 'package:compiler/src/parser/listener.dart' show
+    Listener;
+
+import 'package:compiler/src/parser/node_listener.dart' show
+    NodeListener;
 
 import 'package:compiler/src/io/source_file.dart' show
     CachingUtf8BytesSourceFile,
     SourceFile,
     StringSourceFile;
 
 import 'package:compiler/src/tree/tree.dart' show
     ClassNode,
     FunctionExpression,
     LibraryTag,
@@ skipping 30 matching lines @@
     LinkBuilder;
 
 import 'package:compiler/src/elements/modelx.dart' show
     ClassElementX,
     CompilationUnitElementX,
     DeclarationSite,
     ElementX,
     FieldElementX,
     LibraryElementX;
 
-import 'package:compiler/src/universe/universe.dart' show
-    Selector,
-    UniverseSelector;
-
 import 'package:compiler/src/constants/values.dart' show
     ConstantValue;
 
 import 'package:compiler/src/library_loader.dart' show
     TagState;
 
 import 'diff.dart' show
     Difference,
     computeDifference;
 
@@ skipping 215 matching lines @@
     return _readUri(before.resourceUri).then((bytes) {
       Uri uri = before.file.uri;
       String filename = before.file.filename;
       SourceFile sourceFile = bytes is String
           ? new StringSourceFile(uri, filename, bytes)
           : new CachingUtf8BytesSourceFile(uri, filename, bytes);
       return before.copyWithFile(sourceFile);
     });
   }
 
-  Future<bool> _haveTagsChanged(LibraryElement library) {
+  Future<bool> _haveTagsChanged(LibraryElementX library) {
     Script before = library.entryCompilationUnit.script;
     if (!_context._uriHasUpdate(before.resourceUri)) {
       // The entry compilation unit hasn't been updated. So the tags aren't
       // changed.
       return new Future<bool>.value(false);
     }
 
     return _updatedScript(before, library).then((Script script) {
       _entrySourceFiles[library] = script.file;
       Token token = new Scanner(_entrySourceFiles[library]).tokenize();
       _entryUnitTokens[library] = token;
       // Using two parsers to only create the nodes we want ([LibraryTag]).
       Parser parser = new Parser(new Listener());
+      Element entryCompilationUnit = library.entryCompilationUnit;
       NodeListener listener = new NodeListener(
-          compiler, library.entryCompilationUnit);
+          compiler.resolution.parsing
+              .getScannerOptionsFor(entryCompilationUnit),
+          compiler.reporter, entryCompilationUnit);
       Parser nodeParser = new Parser(listener);
       Iterator<LibraryTag> tags = library.tags.iterator;
       while (token.kind != EOF_TOKEN) {
         token = parser.parseMetadataStar(token);
         if (parser.optional('library', token) ||
             parser.optional('import', token) ||
             parser.optional('export', token) ||
             parser.optional('part', token)) {
           if (!tags.moveNext()) return true;
           token = nodeParser.parseTopLevelDeclaration(token);
@@ skipping 38 matching lines @@
     if (_entryUnitTokens.containsKey(library)) {
       compiler.dietParser.dietParse(
           newLibrary.entryCompilationUnit, _entryUnitTokens[library]);
     } else {
       compiler.scanner.scanLibrary(newLibrary);
     }
 
     TagState tagState = new TagState();
     for (LibraryTag tag in newLibrary.tags) {
       if (tag.isImport) {
-        tagState.checkTag(TagState.IMPORT_OR_EXPORT, tag, compiler);
+        tagState.checkTag(TagState.IMPORT_OR_EXPORT, tag, compiler.reporter);
       } else if (tag.isExport) {
-        tagState.checkTag(TagState.IMPORT_OR_EXPORT, tag, compiler);
+        tagState.checkTag(TagState.IMPORT_OR_EXPORT, tag, compiler.reporter);
       } else if (tag.isLibraryName) {
-        tagState.checkTag(TagState.LIBRARY, tag, compiler);
+        tagState.checkTag(TagState.LIBRARY, tag, compiler.reporter);
         if (newLibrary.libraryTag == null) {
           // Use the first if there are multiple (which is reported as an
           // error in [TagState.checkTag]).
           newLibrary.libraryTag = tag;
         }
       } else if (tag.isPart) {
-        tagState.checkTag(TagState.PART, tag, compiler);
+        tagState.checkTag(TagState.PART, tag, compiler.reporter);
       }
     }
 
     // TODO(ahe): Process tags using TagState, not
     // LibraryLoaderTask.processLibraryTags.
     Link<CompilationUnitElement> units = library.compilationUnits;
     for (Script script in scripts) {
       CompilationUnitElementX unit = units.head;
       units = units.tail;
       if (script != entryScript) {
         // TODO(ahe): Copied from library_loader.
         CompilationUnitElement newUnit =
             new CompilationUnitElementX(script, newLibrary);
-        compiler.withCurrentElement(newUnit, () {
+        compiler.reporter.withCurrentElement(newUnit, () {
           compiler.scanner.scan(newUnit);
           if (unit.partTag == null) {
-            compiler.reportError(unit, MessageKind.MISSING_PART_OF_TAG);
+            compiler.reporter
+                .reportErrorMessage(unit, MessageKind.MISSING_PART_OF_TAG);
           }
         });
       }
     }
 
     logTime('New library synthesized.');
     return canReuseScopeContainerElement(library, newLibrary);
   }
 
   bool cannotReuse(context, String message) {
@@ skipping 199 matching lines @@
 
     updates.add(new RemovedFieldUpdate(compiler, element));
   }
 
   /// Returns true if [element] has generic types (or if we cannot rule out
   /// that it has generic types).
   bool checkForGenericTypes(Element element) {
     if (element is TypeDeclarationElement) {
       if (!element.isResolved) {
         if (element is PartialClassElement) {
-          ClassNode node = element.parseNode(compiler).asClassNode();
+          ClassNode node = element.parseNode(compiler.parsing).asClassNode();
           if (node == null) {
             cannotReuse(
                 element, "Class body isn't a ClassNode on $element");
             return true;
           }
           bool isGeneric =
               node.typeParameters != null && !node.typeParameters.isEmpty;
           if (isGeneric) {
             // TODO(ahe): Support generic types.
             cannotReuse(
@@ skipping 86 matching lines @@
       /* ScopeContainerElement */ container) {
     // TODO(ahe): Use library export graph to compute this.
     // TODO(ahe): Should return all user-defined libraries and packages.
     LibraryElement library = container.library;
     List<ScopeContainerElement> result = <ScopeContainerElement>[library];
 
     if (!container.isClass) return result;
 
     ClassElement cls = container;
 
-    if (!compiler.world.isInstantiated(cls.declaration)) {
-      // dart2js currently only maintain subclasses for classes that are
-      // instantiated.
+    if (!cls.declaration.isResolved) {
+      // TODO(ahe): This test fails otherwise: experimental/add_static_field.
       throw new IncrementalCompilationFailed(
-          "Unable to compute subclasses of ${cls.declaration}");
+          "Unresolved class ${cls.declaration}");
     }
     var externalSubtypes =
         compiler.world.subclassesOf(cls).where((e) => e.library != library);
 
     return result..addAll(externalSubtypes);
   }
 
   /// Returns true if function [before] can be reused to reflect the changes in
   /// [after].
   ///
   /// If [before] can be reused, an update (patch) is added to [updates].
   bool canReuseFunction(
       Token diffToken,
       PartialFunctionElement before,
       PartialFunctionElement after) {
     FunctionExpression node =
-        after.parseNode(compiler).asFunctionExpression();
+        after.parseNode(compiler.parsing).asFunctionExpression();
     if (node == null) {
       return cannotReuse(after, "Not a function expression: '$node'");
     }
     Token last = after.endToken;
     if (node.body != null) {
       last = node.body.getBeginToken();
     }
-    if (before.isErroneous ||
+    if (before.isMalformed ||
         compiler.elementsWithCompileTimeErrors.contains(before) ||
         isTokenBetween(diffToken, after.beginToken, last)) {
       removeFunction(before);
       addFunction(after, before.enclosingElement);
       if (compiler.mainFunction == before) {
         return cannotReuse(
             after,
             "Unable to handle when signature of '${after.name}' changes");
       }
       if (!_context.incrementalCompiler.isExperimentalModeEnabled) {
         return cannotReuse(
             after, "Signature change requires 'experimental' mode");
       }
       return true;
     }
     logVerbose('Simple modification of ${after} detected');
     if (!before.isInstanceMember &&
         !_context.incrementalCompiler.isExperimentalModeEnabled) {
       return cannotReuse(
           after, "Non-instance member requires 'experimental' mode");
     }
     updates.add(new FunctionUpdate(compiler, before, after));
     return true;
   }
 
   bool canReuseClass(
       Token diffToken,
       PartialClassElement before,
       PartialClassElement after) {
-    ClassNode node = after.parseNode(compiler).asClassNode();
+    ClassNode node = after.parseNode(compiler.parsing).asClassNode();
     if (node == null) {
       return cannotReuse(after, "Not a ClassNode: '$node'");
     }
     NodeList body = node.body;
     if (body == null) {
       return cannotReuse(after, "Class has no body.");
     }
     if (isTokenBetween(diffToken, node.beginToken, body.beginToken.next)) {
       if (!_context.incrementalCompiler.isExperimentalModeEnabled) {
         return cannotReuse(
@@ skipping 96 matching lines @@
 
     if (compiler.progress != null) {
       compiler.progress.reset();
     }
 
     for (Element element in updatedElements) {
       if (!element.isClass) {
         enqueuer.resolution.addToWorkList(element);
       } else {
         ClassElement cls = element;
-        cls.ensureResolved(compiler);
+        cls.ensureResolved(compiler.resolution);
 
         // We've told the enqueuer to forget this class, now tell it that it's
         // in use again.  TODO(ahe): We only need to do this if [cls] was
         // already instantiated.
-        enqueuer.codegen.registerInstantiatedType(cls.rawType, null);
+        enqueuer.codegen.registerInstantiatedType(cls.rawType);
       }
     }
     compiler.processQueue(enqueuer.resolution, null);
 
     compiler.phase = Compiler.PHASE_DONE_RESOLVING;
 
     // TODO(ahe): Clean this up. Don't call this method in analyze-only mode.
     if (compiler.analyzeOnly) {
       return new FletchDelta(currentSystem, currentSystem, <Command>[]);
     }
@@ skipping 248 matching lines @@
 
   PartialFunctionElement get after => element;
 
   PartialFunctionElement apply(IncrementalBackend backend) {
     Element enclosing = container;
     if (enclosing.isLibrary) {
       // TODO(ahe): Reuse compilation unit of element instead?
       enclosing = enclosing.compilationUnit;
     }
     PartialFunctionElement copy = element.copyWithEnclosing(enclosing);
-    container.addMember(copy, compiler);
+    container.addMember(copy, compiler.reporter);
     return copy;
   }
 }
 
 class AddedClassUpdate extends Update with FletchFeatures {
   final PartialClassElement element;
 
   final LibraryElementX library;
 
   AddedClassUpdate(Compiler compiler, this.element, this.library)
       : super(compiler);
 
   PartialClassElement get before => null;
 
   PartialClassElement get after => element;
 
   PartialClassElement apply(IncrementalBackend backend) {
     // TODO(ahe): Reuse compilation unit of element instead?
     CompilationUnitElementX compilationUnit = library.compilationUnit;
     PartialClassElement copy = element.copyWithEnclosing(compilationUnit);
-    compilationUnit.addMember(copy, compiler);
+    compilationUnit.addMember(copy, compiler.reporter);
     return copy;
   }
 }
 
 class AddedFieldUpdate extends Update with FletchFeatures {
   final FieldElementX element;
 
   final /* ScopeContainerElement */ container;
 
   AddedFieldUpdate(Compiler compiler, this.element, this.container)
       : super(compiler);
 
   PartialFieldList get before => null;
 
   PartialFieldList get after => element.declarationSite;
 
   FieldElementX apply(IncrementalBackend backend) {
     Element enclosing = container;
     if (enclosing.isLibrary) {
       // TODO(ahe): Reuse compilation unit of element instead?
       enclosing = enclosing.compilationUnit;
     }
     FieldElementX copy = element.copyWithEnclosing(enclosing);
-    container.addMember(copy, compiler);
+    container.addMember(copy, compiler.reporter);
     return copy;
   }
 }
 
 
 class ClassUpdate extends Update with FletchFeatures {
   final PartialClassElement before;
 
   final PartialClassElement after;
 
   ClassUpdate(Compiler compiler, this.before, this.after)
       : super(compiler);
 
   PartialClassElement apply(IncrementalBackend backend) {
     patchElement();
     reuseElement();
     return before;
   }
 
   /// Destructively change the tokens in [before] to match those of [after].
   void patchElement() {
     before.cachedNode = after.cachedNode;
     before.beginToken = after.beginToken;
     before.endToken = after.endToken;
   }
 
   void reuseElement() {
     before.supertype = null;
     before.interfaces = null;
-    before.nativeTagInfo = null;
     before.supertypeLoadState = STATE_NOT_STARTED;
     before.resolutionState = STATE_NOT_STARTED;
     before.isProxy = false;
     before.hasIncompleteHierarchy = false;
     before.backendMembers = const Link<Element>();
     before.allSupertypesAndSelf = null;
   }
 }
 
 /// Returns all qualified names in [element] with less than four identifiers. A
@@ skipping 80 matching lines @@
   }
 
   EnqueueTask get enqueuer => compiler.enqueuer;
 
   FletchContext get fletchContext => compiler.context;
 
   FletchFunctionBuilder lookupFletchFunctionBuilder(FunctionElement function) {
     return backend.systemBuilder.lookupFunctionBuilderByElement(function);
   }
 }