Quick fixes to broken tests.

dart/pkg/dart2js_incremental/lib/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 dart2js_incremental.library_updater;
 
 import 'dart:async' show
     Future;
 
 import 'dart:convert' show
@@ skipping 46 matching lines @@
 import 'package:compiler/src/js_backend/js_backend.dart' show
     JavaScriptBackend,
     Namer;
 
 import 'package:compiler/src/util/util.dart' show
     Link,
     LinkBuilder;
 
 import 'package:compiler/src/elements/modelx.dart' show
     ClassElementX,
+    CompilationUnitElementX,
     DeclarationSite,
     ElementX,
     LibraryElementX;
 
 import 'diff.dart' show
     Difference,
     computeDifference;
 
 typedef void Logger(message);
 
@@ skipping 154 matching lines @@
       return true;
     } else if (element is PartialClassElement) {
       addClass(element, container);
       return true;
     }
     return cannotReuse(element, "Added element that isn't a function.");
   }
 
   void addFunction(
       PartialFunctionElement element,
-      ScopeContainerElement container) {
+      /* ScopeContainerElement */ container) {
     invalidateScopesAffectedBy(element, container);
 
     updates.add(new AddedFunctionUpdate(compiler, element, container));
   }
 
   void addClass(
       PartialClassElement element,
       LibraryElementX library) {
     invalidateScopesAffectedBy(element, library);
 
@@ skipping 29 matching lines @@
     _removedElements.add(element);
     element.forEachLocalMember((ElementX member) {
       _removedElements.add(member);
     });
 
     updates.add(new RemovedClassUpdate(compiler, element));
   }
 
   void invalidateScopesAffectedBy(
       ElementX element,
-      ScopeContainerElement container) {
+      /* ScopeContainerElement */ container) {
     for (ScopeContainerElement scope in scopesAffectedBy(element, container)) {
       scanSites(scope, (Element member, DeclarationSite site) {
         // TODO(ahe): Cache qualifiedNamesIn to avoid quadratic behavior.
         Set<String> names = qualifiedNamesIn(site);
         if (canNamesResolveStaticallyTo(names, element, container)) {
           _elementsToInvalidate.add(member);
         }
       });
     }
   }
 
   /// Invoke [f] on each [DeclarationSite] in [element]. If [element] is a
   /// [ScopeContainerElement], invoke f on all local members as well.
   void scanSites(
       Element element,
       void f(ElementX element, DeclarationSite site)) {
     DeclarationSite site = declarationSite(element);
     if (site != null) {
       f(element, site);
     }
     if (element is ScopeContainerElement) {
       element.forEachLocalMember((member) { scanSites(member, f); });
     }
   }
 
   /// Assume [element] is either removed from or added to [container], and
   /// return all [ScopeContainerElement] that can see this change.
   List<ScopeContainerElement> scopesAffectedBy(
       Element element,
-      ScopeContainerElement container) {
+      /* 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;
 
     var externalSubtypes =
@@ skipping 120 matching lines @@
       if (!element.isClass) {
         compiler.enqueuer.resolution.addToWorkList(element);
       } else {
         element.ensureResolved(compiler);
       }
     }
     compiler.processQueue(compiler.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 "/* analyze only */";
+
     Set<PartialClassElement> changedClasses = new Set<PartialClassElement>();
     for (Element element in updatedElements) {
       if (!element.isClass) {
         compiler.enqueuer.codegen.addToWorkList(element);
       } else {
         changedClasses.add(element);
       }
     }
     compiler.processQueue(compiler.enqueuer.codegen, null);
 
@@ skipping 358 matching lines @@
 
     for (jsAst.Node access in accessToStatics) {
       updates.add(js.statement('delete #', [access]));
     }
   }
 }
 
 class AddedFunctionUpdate extends Update with JsFeatures {
   final PartialFunctionElement element;
 
-  final ScopeContainerElement container;
+  final /* ScopeContainerElement */ container;
 
   AddedFunctionUpdate(Compiler compiler, this.element, this.container)
       : super(compiler) {
     if (container == null) {
       throw "container is null";
     }
   }
 
   PartialFunctionElement get before => null;
 
@@ skipping 16 matching lines @@
 
   final LibraryElementX library;
 
   AddedClassUpdate(Compiler compiler, this.element, this.library)
       : super(compiler);
 
   PartialClassElement get before => null;
 
   PartialClassElement get after => element;
 
-  PartialFunctionElement apply() {
+  PartialClassElement apply() {
     // TODO(ahe): Reuse compilation unit of element instead?
     CompilationUnitElementX compilationUnit = library.compilationUnit;
     PartialClassElement copy = element.copyWithEnclosing(compilationUnit);
     compilationUnit.addMember(copy, compiler);
     return copy;
   }
 }
 
 class ClassUpdate extends Update with JsFeatures {
   final PartialClassElement before;
@@ skipping 83 matching lines @@
     token = token.next;
   } while (token.kind != EOF_TOKEN && token != endToken);
   return names;
 }
 
 /// Returns true if one of the qualified names in names (as computed by
 /// [qualifiedNamesIn]) could be a static reference to [element].
 bool canNamesResolveStaticallyTo(
     Set<String> names,
     Element element,
-    ScopeContainerElement container) {
+    /* ScopeContainerElement */ container) {
   if (names.contains(element.name)) return true;
   if (container != null && container.isClass) {
     // [names] contains C.m, where C is the name of [container], and m is the
     // name of [element].
     if (names.contains("${container.name}.${element.name}")) return true;
   }
   // TODO(ahe): Check for prefixes as well.
   return false;
 }
 
@@ skipping 18 matching lines @@
 
   ClassEmitter get classEmitter => backend.emitter.oldEmitter.classEmitter;
 
   List<String> computeFields(ClassElement cls) {
     // TODO(ahe): Rewrite for new emitter.
     ClassBuilder builder = new ClassBuilder(cls, namer);
     classEmitter.emitFields(cls, builder, "");
     return builder.fields;
   }
 }