Support constructor declarations in analyzer2dart.

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 'elements.dart';
 import '../constants/expressions.dart';
 import '../helpers/helpers.dart';  // Included for debug helpers.
 import '../tree/tree.dart';
@@ skipping 281 matching lines @@
 
   get asyncMarker => AsyncMarker.SYNC;
   Link<MetadataAnnotation> get metadata => unsupported();
   bool get hasNode => false;
   get node => unsupported();
   get hasResolvedAst => false;
   get resolvedAst => unsupported();
   get type => unsupported();
   get cachedNode => unsupported();
   get functionSignature => unsupported();
+  get parameters => unsupported();
   get patch => null;
   get origin => this;
   get immediateRedirectionTarget => unsupported();
   get nestedClosures => unsupported();
   get memberContext => unsupported();
   get executableContext => unsupported();
   get isExternal => unsupported();
 
   bool get isRedirectingFactory => unsupported();
 
@@ skipping 1213 matching lines @@
 
 /// [Element] for a formal parameter.
 ///
 /// A [ParameterElementX] can be patched. A parameter of an external method is
 /// patched with the corresponding parameter of the patch method. This is done
 /// to ensure that default values on parameters are computed once (on the
 /// origin parameter) but can be found through both the origin and the patch.
 abstract class ParameterElementX extends FormalElementX
   with PatchMixin<ParameterElement> implements ParameterElement {
   final Expression initializer;
+  final bool isOptional;
+  final bool isNamed;
 
   ParameterElementX(ElementKind elementKind,
                     FunctionElement functionDeclaration,
                     VariableDefinitions definitions,
                     Identifier identifier,
-                    this.initializer)
+                    this.initializer,
+                    {this.isOptional: false,
+                     this.isNamed: false})
       : super(elementKind, functionDeclaration, definitions, identifier);
 
   FunctionElement get functionDeclaration => enclosingElement;
 
   ExecutableElement get executableContext => enclosingElement;
 
   MemberElement get memberContext => executableContext.memberContext;
 
   accept(ElementVisitor visitor) => visitor.visitParameterElement(this);
 
   bool get isLocal => true;
 }
 
 class LocalParameterElementX extends ParameterElementX
     implements LocalParameterElement {
+
+
   LocalParameterElementX(FunctionElement functionDeclaration,
                          VariableDefinitions definitions,
                          Identifier identifier,
-                         Expression initializer)
+                         Expression initializer,
+                         {bool isOptional: false,
+                          bool isNamed: false})
       : super(ElementKind.PARAMETER, functionDeclaration,
-              definitions, identifier, initializer);
+              definitions, identifier, initializer,
+              isOptional: isOptional, isNamed: isNamed);
 }
 
 /// Parameters in constructors that directly initialize fields. For example:
 /// `A(this.field)`.
 class InitializingFormalElementX extends ParameterElementX
     implements InitializingFormalElement {
   final FieldElement fieldElement;
 
   InitializingFormalElementX(ConstructorElement constructorDeclaration,
                              VariableDefinitions variables,
                              Identifier identifier,
                              Expression initializer,
-                             this.fieldElement)
+                             this.fieldElement,
+                             {bool isOptional: false,
+                              bool isNamed: false})
       : super(ElementKind.INITIALIZING_FORMAL, constructorDeclaration,
-              variables, identifier, initializer);
+              variables, identifier, initializer,
+              isOptional: isOptional, isNamed: isNamed);
 
   accept(ElementVisitor visitor) => visitor.visitFieldParameterElement(this);
 
   MemberElement get memberContext => enclosingElement;
 
   bool get isLocal => false;
 }
 
 class ErroneousInitializingFormalElementX extends ParameterElementX
     implements InitializingFormalElementX {
@@ skipping 212 matching lines @@
     });
     return functionSignatureCache;
   }
 
   FunctionSignature get functionSignature {
     assert(invariant(this, functionSignatureCache != null,
         message: "Function signature has not been computed for $this."));
     return functionSignatureCache;
   }
 
+  List<ParameterElement> get parameters {
+    // TODO(johnniwinther): Store the list directly, possibly by using List
+    // instead of Link in FunctionSignature.
+    List<ParameterElement> list = <ParameterElement>[];
+    functionSignature.forEachParameter((e) => list.add(e));
+    return list;
+  }
+
   FunctionType computeType(Compiler compiler) {
     if (typeCache != null) return typeCache;
     typeCache = computeSignature(compiler).type;
     return typeCache;
   }
 
   FunctionType get type {
     assert(invariant(this, typeCache != null,
         message: "Type has not been computed for $this."));
     return typeCache;
@@ skipping 1225 matching lines @@
   AstElement get definingElement;
 
   bool get hasResolvedAst => definingElement.hasTreeElements;
 
   ResolvedAst get resolvedAst {
     return new ResolvedAst(declaration,
         definingElement.node, definingElement.treeElements);
   }
 
 }