Support compilation of Hello World

pkg/compiler/lib/src/serialization/modelz.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.
 
 /// Implementation of the element model used for deserialiation.
 ///
 /// These classes are created by [ElementDeserializer] triggered by the
 /// [Deserializer].
 
 library dart2js.serialization.modelz;
@@ skipping 46 matching lines @@
     } else if (enclosingElement != null) {
       return enclosingElement.analyzableElement;
     }
     return null;
   }
 
   @override
   FunctionElement asFunctionElement() => null;
 
   @override
-  Scope buildScope() => _unsupported('analyzableElement');
+  Scope buildScope() => _unsupported('buildScope');
 
   @override
   ClassElement get enclosingClass => null;
 
   @override
-  Element get enclosingClassOrCompilationUnit {
-    return _unsupported('enclosingClassOrCompilationUnit');
-  }
-
-  @override
   LibraryElement get implementationLibrary => library;
 
   @override
   bool get isAbstract => false;
 
   @override
   bool get isClassMember => false;
 
   @override
   bool get isClosure => false;
@@ skipping 15 matching lines @@
 
   @override
   bool get isMixinApplication => false;
 
   @override
   bool get isOperator => false;
 
   @override
   bool get isStatic => false;
 
-  // TODO(johnniwinther): Find a more precise semantics for this.
   @override
-  bool get isSynthesized => true;
+  bool get isSynthesized => false;
 
   @override
   bool get isTopLevel => false;
 
   // TODO(johnniwinther): Support metadata.
   @override
   Iterable<MetadataAnnotation> get metadata => const <MetadataAnnotation>[];
 
   @override
   Token get position => _unsupported('position');
 }
 
 abstract class DeserializedElementZ extends ElementZ {
   ObjectDecoder _decoder;
 
   DeserializedElementZ(this._decoder);
 
   @override
   String get name => _decoder.getString(Key.NAME);
 
+  // TODO(johnniwinther): Should this be cached?
+  @override
+  int get sourceOffset => _decoder.getInt(Key.OFFSET, isOptional: true);
+
   @override
   SourceSpan get sourcePosition {
     // TODO(johnniwinther): Should this be cached?
-    int offset = _decoder.getInt(Key.OFFSET, isOptional: true);
+    int offset = sourceOffset;
     if (offset == null) return null;
     Uri uri = _decoder.getUri(Key.URI, isOptional: true);
     if (uri == null) {
       uri = compilationUnit.script.readableUri;
     }
     int length = _decoder.getInt(Key.LENGTH, isOptional: true);
     if (length == null) {
       length = name.length;
     }
     return new SourceSpan(uri, offset, offset + length);
@@ skipping 171 matching lines @@
 
   @override
   CompilationUnitElement get compilationUnit {
     return _canonicalElement.compilationUnit;
   }
 
   @override
   Element get enclosingElement => _canonicalElement.enclosingElement;
 
   @override
+  int get sourceOffset => _canonicalElement.sourceOffset;
+
+  @override
   SourceSpan get sourcePosition => _canonicalElement.sourcePosition;
 
   @override
   ClassElement get enclosingClass => _canonicalElement.enclosingClass;
 }
 
 class LibraryElementZ extends DeserializedElementZ
     with AnalyzableElementMixin, ContainerMixin, LibraryElementCommon
     implements LibraryElement {
   Uri _canonicalUri;
@@ skipping 420 matching lines @@
 
 abstract class ClassElementMixin implements ElementZ, ClassElement {
   InterfaceType _createType(List<DartType> typeArguments) {
     return new InterfaceType(this, typeArguments);
   }
 
   @override
   ElementKind get kind => ElementKind.CLASS;
 
   @override
-  void addBackendMember(Element element) => _unsupported('addBackendMember');
-
-  @override
-  void forEachBackendMember(void f(Element member)) {
-    _unsupported('forEachBackendMember');
-  }
-
-  @override
-  bool get hasBackendMembers => _unsupported('hasBackendMembers');
-
-  @override
   bool get hasConstructor => _unsupported('hasConstructor');
 
   @override
-  bool hasFieldShadowedBy(Element fieldMember) => _unsupported('');
-
-  @override
   bool get hasIncompleteHierarchy => _unsupported('hasIncompleteHierarchy');
 
   @override
   bool get hasLocalScopeMembers => _unsupported('hasLocalScopeMembers');
 
   @override
   bool get isEnumClass => false;
 
   @override
-  Element lookupBackendMember(String memberName) {
-    return _unsupported('lookupBackendMember');
-  }
-
-  @override
   ConstructorElement lookupDefaultConstructor() {
     ConstructorElement constructor = lookupConstructor("");
     if (constructor != null && constructor.parameters.isEmpty) {
       return constructor;
     }
     return null;
   }
 
   @override
-  void reverseBackendMembers() => _unsupported('reverseBackendMembers');
-
-  @override
   ClassElement get superclass => supertype != null ? supertype.element : null;
 
   @override
   void ensureResolved(Resolution resolution) {
     resolution.registerClass(this);
   }
 }
 
 class ClassElementZ extends DeserializedElementZ
     with
@@ skipping 204 matching lines @@
   @override
   bool get isProxy => false;
 
   @override
   LibraryElement get library => enclosingElement.library;
 
   @override
   InterfaceType get mixinType => interfaces.head;
 
   @override
+  int get sourceOffset => _subclass.sourceOffset;
+
+  @override
   SourceSpan get sourcePosition => _subclass.sourcePosition;
 }
 
 class EnumClassElementZ extends ClassElementZ implements EnumClassElement {
   List<FieldElement> _enumValues;
 
   EnumClassElementZ(ObjectDecoder decoder) : super(decoder);
 
   @override
   bool get isEnumClass => true;
 
   @override
   List<FieldElement> get enumValues {
     if (_enumValues == null) {
       _enumValues = _decoder.getElements(Key.FIELDS);
     }
     return _enumValues;
   }
 }
 
 abstract class ConstructorElementZ extends DeserializedElementZ
     with
         AnalyzableElementMixin,
         AstElementMixin,
         ClassMemberMixin,
         FunctionTypedElementMixin,
         ParametersMixin,
         TypedElementMixin,
         MemberElementMixin
-    implements ConstructorElement {
+    implements
+        ConstructorElement,
+        // TODO(johnniwinther): Sort out whether a constructor is a method.
+        MethodElement {
   ConstantConstructor _constantConstructor;
   ConstructorElement _effectiveTarget;
 
   ConstructorElementZ(ObjectDecoder decoder) : super(decoder);
 
   accept(ElementVisitor visitor, arg) {
     return visitor.visitConstructorElement(this, arg);
   }
 
   @override
@@ skipping 44 matching lines @@
       if (_effectiveTarget == null) {
         _effectiveTarget = this;
       }
     }
     return _effectiveTarget;
   }
 
   @override
   ConstructorElement get immediateRedirectionTarget => null;
 
+  // TODO(johnniwinther): Should serialization support erroneous element
+  // relations?

[Siggi Cherem (dart-lang), 2016/04/28 17:23:15]

it might not be worth while. We can fail early and not produce serialized output
if there are errors in the code.

[Johnni Winther, 2016/04/29 09:31:37]

They will be needed for warnings such as a call to `print` with too many
arguments.

   @override
-  bool get isEffectiveTargetMalformed {
-    return _unsupported('isEffectiveTargetMalformed');
-  }
+  bool get isEffectiveTargetMalformed => false;
 
   @override
-  bool get isCyclicRedirection => _unsupported('isCyclicRedirection');
+  bool get isCyclicRedirection => false;
 
   @override
   bool get isRedirectingFactory => false;
 
   @override
   bool get isRedirectingGenerative => false;
 
   @override
   PrefixElement get redirectionDeferredPrefix => null;
 
   @override
   InterfaceType computeEffectiveTargetType(InterfaceType newType) => newType;
 }
 
 class GenerativeConstructorElementZ extends ConstructorElementZ {
   GenerativeConstructorElementZ(ObjectDecoder decoder) : super(decoder);
 
   @override
   ElementKind get kind => ElementKind.GENERATIVE_CONSTRUCTOR;
 
   @override
   bool get isRedirectingGenerative => _decoder.getBool(Key.IS_REDIRECTING);
+
+  @override
+  bool get isSynthesized => definingConstructor != null;
 }
 
 class FactoryConstructorElementZ extends ConstructorElementZ {
   FactoryConstructorElementZ(ObjectDecoder decoder) : super(decoder);
 
   @override
   ElementKind get kind => ElementKind.FACTORY_CONSTRUCTOR;
 }
 
 class RedirectingFactoryConstructorElementZ extends ConstructorElementZ {
@@ skipping 120 matching lines @@
   @override
   bool get isFromEnvironmentConstructor => false;
 
   @override
   bool get isRedirectingFactory => false;
 
   @override
   bool get isRedirectingGenerative => false;
 
   @override
+  bool get isSynthesized => true;
+
+  @override
   ElementKind get kind => ElementKind.GENERATIVE_CONSTRUCTOR;
 
   @override
   LibraryElement get library => enclosingClass.library;
 
   @override
   MemberElement get memberContext => this;
 
   @override
   Name get memberName => definingConstructor.memberName;
 
   @override
   String get name => definingConstructor.name;
 
   @override
   List<FunctionElement> get nestedClosures => const <FunctionElement>[];
 
   @override
   List<ParameterElement> get parameters {
     // TODO(johnniwinther): We need to create synthetic parameters that
     // substitute type variables.
     return definingConstructor.parameters;
   }
 
   // TODO: implement redirectionDeferredPrefix
   @override
   PrefixElement get redirectionDeferredPrefix => null;
 
   @override
+  int get sourceOffset => enclosingClass.sourceOffset;
+
+  @override
   SourceSpan get sourcePosition => enclosingClass.sourcePosition;
 
   @override
   FunctionType get type {
     // TODO(johnniwinther): Ensure that the function type substitutes type
     // variables correctly.
     return definingConstructor.type;
   }
 }
 
@@ skipping 459 matching lines @@
   DartType get bound {
     assert(invariant(this, _bound != null,
         message: "Type variable bound has not been set on $this."));
     return _bound;
   }
 
   @override
   LibraryElement get library => typeDeclaration.library;
 
   @override
+  int get sourceOffset => typeDeclaration.sourceOffset;
+
+  @override
   SourceSpan get sourcePosition => typeDeclaration.sourcePosition;
 }
 
 abstract class ParameterElementZ extends DeserializedElementZ
     with AnalyzableElementMixin, AstElementMixin, TypedElementMixin
     implements ParameterElement {
   FunctionElement _functionDeclaration;
   ConstantExpression _constant;
   DartType _type;
 
@@ skipping 264 matching lines @@
   }
 
   @override
   ElementKind get kind => ElementKind.PREFIX;
 
   @override
   Element lookupLocalMember(String memberName) {
     return _unsupported('lookupLocalMember');
   }
 }