Support parameter access 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 100 matching lines @@
   Element get origin {
     throw new UnsupportedError('origin is not supported on $this');
   }
 
   bool get isSynthesized => false;
 
   bool get isForwardingConstructor => false;
 
   bool get isMixinApplication => false;
 
+  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;
   }
 
   bool get isAssignable {
     if (isFinal || isConst) return false;
@@ skipping 1091 matching lines @@
   // TODO(johnniwinther): Remove this when the dart `backend_ast` does not need
   // [Element] for entities.
   LocalVariableElementX.synthetic(String name,
                                   ExecutableElement enclosingElement,
                                   VariableList variables)
       : super(name, ElementKind.VARIABLE, enclosingElement, variables, null);
 
   ExecutableElement get executableContext => enclosingElement;
 
   ExecutableElement get memberContext => executableContext.memberContext;
+
+  bool get isLocal => true;
 }
 
 class FieldElementX extends VariableElementX
     with AnalyzableElementX implements FieldElement {
   List<FunctionElement> nestedClosures = new List<FunctionElement>();
 
   FieldElementX(Identifier name,
                 Element enclosingElement,
                 VariableList variables)
     : super(name.source, ElementKind.FIELD, enclosingElement,
@@ skipping 86 matching lines @@
                     this.initializer)
       : 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)
       : super(ElementKind.PARAMETER, functionDeclaration,
               definitions, identifier, initializer);
 }
 
 /// Parameters in constructors that directly initialize fields. For example:
 /// `A(this.field)`.
 class InitializingFormalElementX extends ParameterElementX
     implements InitializingFormalElement {
   FieldElement fieldElement;
 
   InitializingFormalElementX(ConstructorElement constructorDeclaration,
                              VariableDefinitions variables,
                              Identifier identifier,
                              Expression initializer,
                              this.fieldElement)
       : super(ElementKind.INITIALIZING_FORMAL, constructorDeclaration,
               variables, identifier, initializer);
 
   accept(ElementVisitor visitor) => visitor.visitFieldParameterElement(this);
 
   MemberElement get memberContext => enclosingElement;
+
+  bool get isLocal => false;
 }
 
 
 class AbstractFieldElementX extends ElementX implements AbstractFieldElement {
   FunctionElementX getter;
   FunctionElementX setter;
 
   AbstractFieldElementX(String name, Element enclosing)
       : super(name, ElementKind.ABSTRACT_FIELD, enclosing);
 
@@ skipping 255 matching lines @@
   FunctionExpression parseNode(DiagnosticListener listener) => node;
 
   Token get position {
     // Use the name as position if this is not an unnamed closure.
     if (node.name != null) {
       return node.name.getBeginToken();
     } else {
       return node.getBeginToken();
     }
   }
+
+  bool get isLocal => true;
 }
 
 abstract class ConstructorElementX extends FunctionElementX
     implements ConstructorElement {
 
   ConstructorElementX(String name,
                       ElementKind kind,
                       Modifiers modifiers,
                       Element enclosing)
         : super(name, kind, modifiers, enclosing, false);
@@ skipping 1032 matching lines @@
   AstElement get definingElement;
 
   bool get hasResolvedAst => definingElement.hasTreeElements;
 
   ResolvedAst get resolvedAst {
     return new ResolvedAst(declaration,
         definingElement.node, definingElement.treeElements);
   }
 
 }