First end-to-end capability in analyzer2dart.

sdk/lib/_internal/compiler/implementation/elements/modelx.dart

 // Copyright (c) 2013, 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 elements.modelx;
 
 import 'elements.dart';
 import '../helpers/helpers.dart';  // Included for debug helpers.
 import '../tree/tree.dart';
 import '../util/util.dart';
@@ skipping 251 matching lines @@
 }
 
 class ErroneousElementX extends ElementX implements ErroneousElement {
   final MessageKind messageKind;
   final Map messageArguments;
 
   ErroneousElementX(this.messageKind, this.messageArguments,
                     String name, Element enclosing)
       : super(name, ElementKind.ERROR, enclosing);
 
+  bool get isTopLevel => false;
+
   bool get isSynthesized => true;
 
   AbstractFieldElement abstractField;
 
   unsupported() {
     throw 'unsupported operation on erroneous element';
   }
 
   Link<MetadataAnnotation> get metadata => unsupported();
   bool get hasNode => false;
@@ skipping 137 matching lines @@
       listener.withCurrentElement(importer, () {
         for (; !importers.isEmpty; importers = importers.tail) {
           listener.reportInfo(
               importers.head, MessageKind.IMPORTED_HERE, arguments);
         }
       });
     }
   }
 
   accept(ElementVisitor visitor) => visitor.visitAmbiguousElement(this);
+
+  bool get isTopLevel => false;
 }
 
 class ScopeX {
   final Map<String, Element> contents = new Map<String, Element>();
 
   bool get isEmpty => contents.isEmpty;
   Iterable<Element> get values => contents.values;
 
   Element lookup(String name) {
     return contents[name];
@@ skipping 290 matching lines @@
                   [Uri canonicalUri, LibraryElementX origin])
     : this.canonicalUri =
           ((canonicalUri == null) ? script.readableUri : canonicalUri),
       super(script.name, ElementKind.LIBRARY, null) {
     entryCompilationUnit = new CompilationUnitElementX(script, this);
     if (origin != null) {
       origin.applyPatch(this);
     }
   }
 
+  bool get isDartCore => canonicalUri == Compiler.DART_CORE;
+
   Link<MetadataAnnotation> get metadata {
     return (libraryTag == null) ? super.metadata : libraryTag.metadata;
   }
 
   set metadata(value) {
     // The metadata is stored on [libraryTag].
     throw new SpannableAssertionFailure(this, 'Cannot set metadata on Library');
   }
 
   CompilationUnitElement get compilationUnit => entryCompilationUnit;
@@ skipping 221 matching lines @@
 
   bool get isDeferred => _deferredImport != null;
 
   // Only needed for deferred imports.
   Import _deferredImport;
   Import get deferredImport => _deferredImport;
 
   PrefixElementX(String prefix, Element enclosing, this.firstPosition)
       : super(prefix, ElementKind.PREFIX, enclosing);
 
+  bool get isTopLevel => false;
+
   Element lookupLocalMember(String memberName) => importScope[memberName];
 
   DartType computeType(Compiler compiler) => const DynamicType();
 
   Token get position => firstPosition;
 
   void addImport(Element element, Import import, DiagnosticListener listener) {
     importScope.addImport(this, element, import, listener);
   }
 
@@ skipping 701 matching lines @@
   bool isForeign(Backend backend) => true;
 
   bool get isSynthesized => true;
 
   bool get isFunction => false;
 
   bool get isDeferredLoaderGetter => true;
 
   bool get isGetter => true;
 
+  bool get isTopLevel => true;
   // By having position null, the enclosing elements location is printed in
   // error messages.
   Token get position => null;
 
   FunctionExpression parseNode(DiagnosticListener listener) => null;
 
   bool get hasNode => false;
 
   FunctionExpression get node => null;
 }
@@ skipping 954 matching lines @@
   AstElement get definingElement;
 
   bool get hasResolvedAst => definingElement.hasTreeElements;
 
   ResolvedAst get resolvedAst {
     return new ResolvedAst(declaration,
         definingElement.node, definingElement.treeElements);
   }
 
 }