Support compilation of Hello World

pkg/compiler/lib/src/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 '../common.dart';
 import '../common/resolution.dart' show Resolution, ParsingContext;
 import '../compiler.dart' show Compiler;
 import '../constants/constant_constructors.dart';
@@ skipping 91 matching lines @@
   bool get isLocal => false;
 
   // TODO(johnniwinther): This breaks for libraries (for which enclosing
   // elements are null) and is invalid for top level variable declarations for
   // which the enclosing element is a VariableDeclarations and not a compilation
   // unit.
   bool get isTopLevel {
     return enclosingElement != null && enclosingElement.isCompilationUnit;
   }
 
+  @override
+  int get sourceOffset => position?.charOffset;
+
   Token get position => null;
 
   SourceSpan get sourcePosition {
     if (position == null) return null;
     Uri uri = compilationUnit.script.resourceUri;
-    return new SourceSpan(
-        uri, position.charOffset, position.charOffset + position.charCount);
+    return new SourceSpan(uri, position.charOffset, position.charEnd);
   }
 
   Token findMyName(Token token) {
     return findNameToken(token, isConstructor, name, enclosingElement.name);
   }
 
   static Token findNameToken(
       Token token, bool isConstructor, String name, String enclosingClassName) {
     // We search for the token that has the name of this element.
     // For constructors, that doesn't work because they may have
@@ skipping 28 matching lines @@
     return element;
   }
 
   ClassElement get enclosingClass {
     for (Element e = this; e != null; e = e.enclosingElement) {
       if (e.isClass) return e;
     }
     return null;
   }
 
-  Element get enclosingClassOrCompilationUnit {
-    for (Element e = this; e != null; e = e.enclosingElement) {
-      if (e.isClass || e.isCompilationUnit) return e;
-    }
-    return null;
-  }
-
   /**
    * Creates the scope for this element.
    */
   Scope buildScope() => enclosingElement.buildScope();
 
   String toString() {
     // TODO(johnniwinther): Test for nullness of name, or make non-nullness an
     // invariant for all element types?
     var nameText = name != null ? name : '?';
     if (enclosingElement != null && !isTopLevel) {
@@ skipping 2296 matching lines @@
     implements ClassElement {
   final int id;
 
   DartType supertype;
   Link<DartType> interfaces;
   int supertypeLoadState;
   int resolutionState;
   bool isProxy = false;
   bool hasIncompleteHierarchy = false;
 
-  // backendMembers are members that have been added by the backend to simplify
-  // compilation. They don't have any user-side counter-part.
-  Link<Element> backendMembers = const Link<Element>();
-
   OrderedTypeSet allSupertypesAndSelf;
 
   BaseClassElementX(String name, Element enclosing, this.id, int initialState)
       : supertypeLoadState = initialState,
         resolutionState = initialState,
         super(name, ElementKind.CLASS, enclosing);
 
   int get hashCode => id;
 
-  bool get hasBackendMembers => !backendMembers.isEmpty;
-
   bool get isUnnamedMixinApplication => false;
 
   @override
   bool get isEnumClass => false;
 
   InterfaceType computeType(Resolution resolution) {
     if (isPatch) {
       origin.computeType(resolution);
       thisTypeCache = origin.thisType;
       rawTypeCache = origin.rawType;
@@ skipping 32 matching lines @@
   void ensureResolved(Resolution resolution) {
     if (resolutionState == STATE_NOT_STARTED) {
       resolution.resolveClass(this);
       resolution.registerClass(this);
     }
   }
 
   void setDefaultConstructor(
       FunctionElement constructor, DiagnosticReporter reporter);
 
-  void addBackendMember(Element member) {
-    // TODO(ngeoffray): Deprecate this method.
-    assert(member.isGenerativeConstructorBody);
-    backendMembers = backendMembers.prepend(member);
-  }
-
-  void reverseBackendMembers() {
-    backendMembers = backendMembers.reverse();
-  }
-
-  /// Lookup a synthetic element created by the backend.
-  Element lookupBackendMember(String memberName) {
-    for (Element element in backendMembers) {
-      if (element.name == memberName) {
-        return element;
-      }
-    }
-    return null;
-  }
-
   ConstructorElement lookupDefaultConstructor() {
     ConstructorElement constructor = lookupConstructor("");
     // This method might be called on constructors that have not been
     // resolved. As we query the live world, we return `null` in such cases
     // as no default constructor exists in the live world.
     if (constructor != null &&
         constructor.hasFunctionSignature &&
         constructor.functionSignature.requiredParameterCount == 0) {
       return constructor;
     }
     return null;
   }
 
   /**
    * Returns the super class, if any.
    *
    * The returned element may not be resolved yet.
    */
   ClassElement get superclass {
     assert(invariant(this, supertypeLoadState == STATE_DONE,
         message: "Superclass has not been computed for $this."));
     return supertype == null ? null : supertype.element;
   }
 
-  void forEachBackendMember(void f(Element member)) {
-    backendMembers.forEach(f);
-  }
-
   // TODO(johnniwinther): Remove these when issue 18630 is fixed.
   ClassElement get patch => super.patch;
   ClassElement get origin => super.origin;
 
   // A class declaration is defined by the declaration element.
   AstElement get definingElement => declaration;
 }
 
 abstract class ClassElementX extends BaseClassElementX {
   Link<Element> localMembersReversed = const Link<Element>();
@@ skipping 659 matching lines @@
     if (definingElement.isField) {
       FieldElement field = definingElement;
       body = field.initializer;
     } else if (node != null && node.asFunctionExpression() != null) {
       body = node.asFunctionExpression().body;
     }
     return new ParsedResolvedAst(
         declaration, node, body, definingElement.treeElements);
   }
 }