Renamed isParameter to isRegularParameter.

pkg/compiler/lib/src/resolution/members.dart

 // Copyright (c) 2012, 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 dart2js.resolution.members;
 
 import '../common.dart';
 import '../common/names.dart' show Selectors;
 import '../common/resolution.dart' show Feature;
 import '../compiler.dart' show Compiler;
@@ skipping 94 matching lines @@
   /// the initializer of the variable is implicit and we should not emit an
   /// error when verifying that all final variables are initialized.
   bool inLoopVariable = false;
 
   /// The nodes for which variable access and mutation must be registered in
   /// order to determine when the static type of variables types is promoted.
   Link<Node> promotionScope = const Link<Node>();
 
   bool isPotentiallyMutableTarget(Element target) {
     if (target == null) return false;
-    return (target.isVariable || target.isParameter) &&
+    return (target.isVariable || target.isRegularParameter) &&
         !(target.isFinal || target.isConst);
   }
 
   // TODO(ahe): Find a way to share this with runtime implementation.
   static final RegExp symbolValidationPattern =
       new RegExp(r'^(?:[a-zA-Z$][a-zA-Z$0-9_]*\.)*(?:[a-zA-Z$][a-zA-Z$0-9_]*=?|'
           r'-|'
           r'unary-|'
           r'\[\]=|'
           r'~|'
@@ skipping 746 matching lines @@
             message: "Unexpected super setter '$setter'."));
         return new CompoundAccessSemantics(
             CompoundAccessKind.SUPER_METHOD_SETTER, getter, setter);
       }
     }
   }
 
   /// Compute the [AccessSemantics] corresponding to a local access of [target].
   AccessSemantics computeLocalAccessSemantics(
       Spannable node, LocalElement target) {
-    if (target.isParameter) {
+    if (target.isRegularParameter) {
       if (target.isFinal || target.isConst) {
         return new StaticAccess.finalParameter(target);
       } else {
         return new StaticAccess.parameter(target);
       }
     } else if (target.isInitializingFormal) {
       return new StaticAccess.finalParameter(target);
     } else if (target.isVariable) {
       if (target.isFinal || target.isConst) {
         return new StaticAccess.finalLocalVariable(target);
@@ skipping 1659 matching lines @@
 
     registerPotentialAccessInClosure(node, element);
 
     return result;
   }
 
   /// Handle update of a parameter, local variable or local function.
   ResolutionResult handleLocalUpdate(Send node, Name name, Element element) {
     AccessSemantics semantics;
     ErroneousElement error;
-    if (element.isParameter) {
+    if (element.isRegularParameter) {
       if (element.isFinal) {
         error = reportAndCreateErroneousElement(node.selector, name.text,
             MessageKind.UNDEFINED_STATIC_SETTER_BUT_GETTER, {'name': name});
         semantics = new StaticAccess.finalParameter(element);
       } else {
         semantics = new StaticAccess.parameter(element);
       }
     } else if (element.isInitializingFormal &&
         compiler.options.enableInitializingFormalAccess) {
       error = reportAndCreateErroneousElement(node.selector, name.text,
@@ skipping 2149 matching lines @@
     }
     return const NoneResult();
   }
 }
 
 /// Looks up [name] in [scope] and unwraps the result.
 Element lookupInScope(
     DiagnosticReporter reporter, Node node, Scope scope, String name) {
   return Elements.unwrap(scope.lookup(name), reporter, node);
 }