Support constructor declarations in analyzer2dart.

pkg/analyzer2dart/lib/src/modely.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.
 
 part of analyzer2dart.element_converter;
 
 
 /// Base [dart2js.Element] implementation for converted analyzer elements.
 class ElementY extends dart2js.Element {
   final ElementConverter converter;
@@ skipping 219 matching lines @@
   @override
   void addMember(element, listener) => unsupported('addMember');
 
   @override
   void addTag(tag, listener) => unsupported('addTag');
 
   @override
   void addToScope(element, listener) => unsupported('addToScope');
 
   @override
-  void set canUseNative(bool value) => unsupported('canUseNative');

[Johnni Winther, 2015/01/28 13:38:01]

Cleanup.

-
-  @override
   bool get canUseNative => unsupported('canUseNative');
 
   @override
   Uri get canonicalUri => unsupported('canonicalUri');
 
   @override
   int compareTo(other) => unsupported('compareTo');
 
   @override
   get compilationUnits => unsupported('compilationUnits');
@@ skipping 87 matching lines @@
   // TODO(johnniwinther): Ensure the correct semantics of this.
   @override
   bool get isAbstract => false;
 
   @override
   dart2js.ClassElement get enclosingClass => null;
 }
 
 abstract class FunctionElementMixin
     implements ElementY, dart2js.FunctionElement {
+  analyzer.ExecutableElement get element;
 
   // TODO(johnniwinther): Ensure the correct semantics of this.
   @override
   bool get isExternal => false;
 
   @override
   bool get isConst => false;
 
   @override
   get abstractField => unsupported('abstractField');
 
   @override
   computeSignature(_) => unsupported('computeSignature');
 
   @override
   get memberContext => unsupported('memberContext');
 
   @override
   get functionSignature => unsupported('functionSignature');
 
   @override
   bool get hasFunctionSignature => unsupported('hasFunctionSignature');
 
   @override
   get asyncMarker => unsupported('asyncMarker');
+
+  @override
+  List<dart2js.ParameterElement> get parameters {
+    return element.parameters.map(converter.convertElement).toList();
+  }
+
+  @override
+  dart2js.FunctionType get type => converter.convertType(element.type);
 }
 
 class TopLevelFunctionElementY extends ElementY
     with AnalyzableElementY,
          AstElementY,
          TopLevelElementMixin,
          FunctionElementMixin
     implements dart2js.FunctionElement {
   analyzer.FunctionElement get element => super.element;
 
   @override
   dart2js.ElementKind get kind => dart2js.ElementKind.FUNCTION;
 
-  @override
-  dart2js.FunctionType get type => converter.convertType(element.type);
-
   TopLevelFunctionElementY(ElementConverter converter,
                            analyzer.FunctionElement element)
       : super(converter, element);
 }
 
 class LocalFunctionElementY extends ElementY
     with AnalyzableElementY,
          AstElementY,
          LocalElementMixin,
          FunctionElementMixin
     implements dart2js.LocalFunctionElement {
   analyzer.FunctionElement get element => super.element;
 
   @override
   dart2js.ElementKind get kind => dart2js.ElementKind.FUNCTION;
 
   @override
-  dart2js.FunctionType get type => converter.convertType(element.type);
-
-  @override
   bool get isAbstract => false;
 
   @override
   bool get isConst => false;
 
   LocalFunctionElementY(ElementConverter converter,
                         analyzer.FunctionElement element)
       : super(converter, element);
 }
 
@@ skipping 11 matching lines @@
 
   @override
   bool get isLocal => true;
 
   @override
   bool get isStatic => false;
 
   @override
   bool get isConst => false;
 
+  @override
+  bool get isNamed => element.parameterKind == ParameterKind.NAMED;
+
+  @override
+  bool get isOptional => element.parameterKind.isOptional;
+
   ParameterElementY(ElementConverter converter,
                     analyzer.ParameterElement element)
       : super(converter, element) {
     assert(!element.isInitializingFormal);
   }
 
   @override
   get executableContext => unsupported('executableContext');
 
   @override
@@ skipping 27 matching lines @@
   get rawType => null;//unsupported('rawType');
 
   @override
   int get resolutionState => unsupported('resolutionState');
 
   @override
   get thisType => unsupported('thisType');
 
   @override
   get typeVariables => unsupported('typeVariables');
-
 }
 
 class ClassElementY extends TypeDeclarationElementY
     implements dart2js.ClassElement {
 
   analyzer.ClassElement get element => super.element;
 
   dart2js.ElementKind get kind => dart2js.ElementKind.CLASS;
 
   @override
   bool get isObject => element.type.isObject;
 
+  // TODO(johnniwinther): Ensure the correct semantics.
+  // TODO(paulberry,brianwilkerson): [ClassElement.isTypedef] should probably
+  // be renamed to [ClassElement.isNamedMixinApplication].
+  @override
+  bool get isMixinApplication => element.isTypedef;
+
+  @override
+  bool get isUnnamedMixinApplication => false;
+
+  @override
+  bool get isEnumClass => element.isEnum;
+
+  @override
+  bool get isAbstract => element.isAbstract;
+
+  // TODO(johnniwinther): Semantic difference: Dart2js points to unnamed
+  // mixin applications, analyzer points to the type in the extends clause or
+  // Object if omitted.
+  @override
+  dart2js.DartType get supertype {
+    return element.supertype != null
+        ? converter.convertType(element.supertype)
+        : null;
+  }
+
+  @override
+  util.Link<dart2js.DartType> get interfaces {
+    // TODO(johnniwinther): Support interfaces.
+    return const util.Link<dart2js.DartType>();
+  }
+
+  // TODO(johnniwinther): Support generic classes.
+  @override
+  List<dart2js.DartType> get typeVariables => const [];
+
+  @override
+  bool get isStatic => false;
+
+  @override
+  bool get isTopLevel => true;
+
+  @override
+  dart2js.ClassElement get enclosingClass => this;
+
   ClassElementY(ElementConverter converter, analyzer.ClassElement element)
       : super(converter, element);
 
   @override
   void addBackendMember(element) => unsupported('addBackendMember');
 
   @override
   void addMember(element, listener) => unsupported('addMember');
 
   @override
@@ skipping 65 matching lines @@
   @override
   int get id => unsupported('id');
 
   @override
   bool implementsFunction(compiler) => unsupported('implementsFunction');
 
   @override
   bool implementsInterface(intrface) => unsupported('implementsInterface');
 
   @override
-  get interfaces => unsupported('interfaces');
-
-  @override
   bool get isProxy => unsupported('isProxy');
 
   @override
   bool isSubclassOf(cls) => unsupported('isSubclassOf');
 
   @override
-  get isUnnamedMixinApplication => unsupported('isUnnamedMixinApplication');
-
-  @override
   localLookup(String elementName) => unsupported('localLookup');
 
   @override
   lookupBackendMember(String memberName) => unsupported('lookupBackendMember');
 
   @override
   lookupClassMember(name) => unsupported('lookupClassMember');
 
   @override
   lookupConstructor(selector, [noMatch]) => unsupported('lookupConstructor');
@@ skipping 21 matching lines @@
   @override
   lookupSuperSelector(selector) => unsupported('lookupSuperSelector');
 
   @override
   String get nativeTagInfo => unsupported('nativeTagInfo');
 
   @override
   void reverseBackendMembers() => unsupported('reverseBackendMembers');
 
   @override
-  void setDefaultConstructor(constructor, compiler) {
-    unsupported('setDefaultConstructor');
-  }
-
-  @override
   dart2js.ClassElement get superclass => unsupported('superclass');
 
-  // TODO(johnniwinther): Semantic difference: Dart2js points to unnamed
-  // mixin applications, analyzer points to the type in the extends clause or
-  // Object if omitted.
-  @override
-  dart2js.DartType get supertype => unsupported('supertype');
-
   @override
   int get supertypeLoadState => unsupported('supertypeLoadState');
 
   @override
   validateConstructorLookupResults(selector,  result, noMatch) {
     unsupported('validateConstructorLookupResults');
   }
-
-  @override
-  bool get isEnumClass => unsupported('isEnum');
 }
 
 class TypedefElementY extends TypeDeclarationElementY
     implements dart2js.TypedefElement {
 
   analyzer.FunctionTypeAliasElement get element => super.element;
 
   dart2js.ElementKind get kind => dart2js.ElementKind.TYPEDEF;
 
   TypedefElementY(ElementConverter converter,
@@ skipping 78 matching lines @@
   bool get isConst => element.isConst;
 
   LocalVariableElementY(ElementConverter converter,
                         analyzer.LocalVariableElement element)
       : super(converter, element);
 
   @override
   dart2js.DartType get type => unsupported('type');
 }
 
-class ConstructorElementY extends ElementY
-    with AnalyzableElementY,
-         AstElementY,
-         FunctionElementMixin
-    implements dart2js.ConstructorElement {
+abstract class ClassMemberMixin implements ElementY {
+  analyzer.ClassMemberElement get element;
 
-  analyzer.ConstructorElement get element => super.element;
+  @override
+  dart2js.ClassElement get contextClass => enclosingClass;
 
   @override
   dart2js.ClassElement get enclosingClass {
     return converter.convertElement(element.enclosingElement);
   }
 
+  @override
+  bool get isClassMember => true;
+}
+
+class ConstructorElementY extends ElementY
+    with AnalyzableElementY,
+         AstElementY,
+         FunctionElementMixin,
+         ClassMemberMixin
+    implements dart2js.ConstructorElement {
+
+  analyzer.ConstructorElement get element => super.element;
+
   // TODO(johnniwinther): Support redirecting/factory constructors.
   @override
   dart2js.ElementKind get kind => dart2js.ElementKind.GENERATIVE_CONSTRUCTOR;
 
+  // TODO(johnniwinther): Support factory constructors.
+  @override
+  bool get isFactoryConstructor => false;
+
+  // TODO(johnniwinther): Support redirecting factory constructors.
+  @override
+  bool get isRedirectingFactory => false;
+
+  @override
+  bool get isStatic => false;
+
   ConstructorElementY(ElementConverter converter,
                       analyzer.ConstructorElement element)
       : super(converter, element);
 
   @override
   computeEffectiveTargetType(_) => unsupported('computeEffectiveTargetType');
 
   @override
   get definingConstructor => unsupported('definingConstructor');
 
   @override
   get effectiveTarget => unsupported('effectiveTarget');
 
   @override
   get immediateRedirectionTarget => unsupported('immediateRedirectionTarget');
 
   @override
-  bool get isRedirectingFactory => unsupported('isRedirectingFactory');
-
-  @override
   get nestedClosures => unsupported('nestedClosures');
-
-  @override
-  get type => unsupported('type');
 }