Implementation of modified scoping for initializing formals.

pkg/compiler/lib/src/resolution/constructors.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.
 
 library dart2js.resolution.constructors;
 
 import '../common.dart';
 import '../common/resolution.dart' show Feature;
 import '../compiler.dart' show Compiler;
 import '../constants/constructors.dart'
@@ skipping 14 matching lines @@
         ParameterElementX;
 import '../tree/tree.dart';
 import '../util/util.dart' show Link;
 import '../universe/call_structure.dart' show CallStructure;
 import '../universe/use.dart' show StaticUse;
 
 import 'members.dart' show lookupInScope, ResolverVisitor;
 import 'registry.dart' show ResolutionRegistry;
 import 'resolution_common.dart' show CommonResolverVisitor;
 import 'resolution_result.dart';
+import 'scope.dart' show Scope, ExtensionScope;
 
 class InitializerResolver {
   final ResolverVisitor visitor;
   final ConstructorElementX constructor;
   final FunctionExpression functionNode;
   final Map<FieldElement, Node> initialized = <FieldElement, Node>{};
   final Map<FieldElement, ConstantExpression> fieldInitializers =
       <FieldElement, ConstantExpression>{};
   Link<Node> initializers;
   bool hasSuper = false;
@@ skipping 242 matching lines @@
             node, constructorName, kind, {});
       }
     }
     return result;
   }
 
   /**
    * Resolve all initializers of this constructor. In the case of a redirecting
    * constructor, the resolved constructor's function element is returned.
    */
-  ConstructorElement resolveInitializers() {
+  ConstructorElement resolveInitializers(
+      {bool enableInitializingFormalAccess: false}) {
     Map<dynamic /*String|int*/, ConstantExpression> defaultValues =
         <dynamic /*String|int*/, ConstantExpression>{};
     ConstructedConstantExpression constructorInvocation;
     // Keep track of all "this.param" parameters specified for constructor so
     // that we can ensure that fields are initialized only once.
     FunctionSignature functionParameters = constructor.functionSignature;
+    Scope oldScope = visitor.scope;
+    if (enableInitializingFormalAccess) {
+      // In order to get the correct detection of name clashes between all
+      // parameters (regular ones and initializing formals) we must extend
+      // the parameter scope rather than adding a new nested scope.
+      visitor.scope = new ExtensionScope(visitor.scope);
+    }
+    Link<Node> parameterNodes = (functionNode.parameters == null)
+        ? const Link<Node>()
+        : functionNode.parameters.nodes;
     functionParameters.forEachParameter((ParameterElementX element) {
+      List<Element> optionals = functionParameters.optionalParameters;
+      if (!optionals.isEmpty && element == optionals.first) {
+        NodeList nodes = parameterNodes.head;
+        parameterNodes = nodes.nodes;
+      }
       if (isConst) {
         if (element.isOptional) {
           if (element.constantCache == null) {
             // TODO(johnniwinther): Remove this when all constant expressions
             // can be computed during resolution.
             isValidAsConstant = false;
           } else {
             ConstantExpression defaultValue = element.constant;
             if (defaultValue != null) {
               if (element.isNamed) {
                 defaultValues[element.name] = defaultValue;
               } else {
                 int index =
                     element.functionDeclaration.parameters.indexOf(element);
                 defaultValues[index] = defaultValue;
               }
             } else {
               isValidAsConstant = false;
             }
           }
         }
       }
       if (element.isInitializingFormal) {
+        VariableDefinitions variableDefinitions = parameterNodes.head;
+        Node parameterNode = variableDefinitions.definitions.nodes.head;
         InitializingFormalElementX initializingFormal = element;
         FieldElement field = initializingFormal.fieldElement;
         checkForDuplicateInitializers(field, element.initializer);
+        if (enableInitializingFormalAccess) {
+          visitor.defineLocalVariable(parameterNode, initializingFormal);
+          visitor.addToScope(initializingFormal);
+        }
         if (isConst) {
           if (element.isNamed) {
             fieldInitializers[field] = new NamedArgumentReference(element.name);
           } else {
             int index = element.functionDeclaration.parameters.indexOf(element);
             fieldInitializers[field] = new PositionalArgumentReference(index);
           }
         } else {
           isValidAsConstant = false;
         }
       }
+      parameterNodes = parameterNodes.tail;
     });
 
     if (functionNode.initializers == null) {
       initializers = const Link<Node>();
     } else {
       initializers = functionNode.initializers.nodes;
     }
     bool resolvedSuper = false;
     for (Link<Node> link = initializers; !link.isEmpty; link = link.tail) {
       if (link.head.asSendSet() != null) {
@@ skipping 71 matching lines @@
     if (!resolvedSuper) {
       constructorInvocation = resolveImplicitSuperConstructorSend();
     }
     if (isConst && isValidAsConstant) {
       constructor.constantConstructor = new GenerativeConstantConstructor(
           constructor.enclosingClass.thisType,
           defaultValues,
           fieldInitializers,
           constructorInvocation);
     }
+    visitor.scope = oldScope;
     return null; // If there was no redirection always return null.
   }
 }
 
 class ConstructorResolver extends CommonResolverVisitor<ConstructorResult> {
   final ResolverVisitor resolver;
   final bool inConstContext;
 
   ConstructorResolver(Compiler compiler, this.resolver,
       {bool this.inConstContext: false})
@@ skipping 407 matching lines @@
     // constructors.
     return null;
   }
   // TODO(johnniwinther): Use [Name] for lookup.
   ConstructorElement constructor = cls.lookupConstructor(constructorName);
   if (constructor != null) {
     constructor = constructor.declaration;
   }
   return constructor;
 }