Make initializing formal access available by default

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 Resolution;
 import '../constants/constructors.dart'
     show
@@ skipping 276 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(
-      {bool enableInitializingFormalAccess: false}) {
+  ConstructorElement resolveInitializers() {
     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);
-    }
+    // 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) {
@@ skipping 20 matching lines @@
       }
       if (element.isInitializingFormal) {
         VariableDefinitions variableDefinitions = parameterNodes.head;
         Node parameterNode = variableDefinitions.definitions.nodes.head;
         InitializingFormalElementX initializingFormal = element;
         FieldElement field = initializingFormal.fieldElement;
         if (!field.isMalformed) {
           registry.registerStaticUse(new StaticUse.fieldInit(field));
         }
         checkForDuplicateInitializers(field, element.initializer);
-        if (enableInitializingFormalAccess) {
-          visitor.defineLocalVariable(parameterNode, initializingFormal);
-          visitor.addToScope(initializingFormal);
-        }
+        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;
         }
@@ skipping 518 matching lines @@
     // constructors.
     return null;
   }
   // TODO(johnniwinther): Use [Name] for lookup.
   ConstructorElement constructor = cls.lookupConstructor(constructorName);
   if (constructor != null) {
     constructor = constructor.declaration;
   }
   return constructor;
 }