Make initializing formal access available by default

pkg/compiler/lib/src/typechecker.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.typechecker;
 
 import 'common/names.dart' show Identifiers;
 import 'common/resolution.dart' show Resolution;
 import 'common/tasks.dart' show CompilerTask;
 import 'common.dart';
@@ skipping 668 matching lines @@
     if (node.isThis()) {
       return thisType;
     } else if (node.isSuper()) {
       return superType;
     } else {
       TypedElement element = elements[node];
       assert(invariant(node, element != null,
           message: 'Missing element for identifier'));
       assert(invariant(
           node,
-          element.isVariable ||
-              element.isRegularParameter ||
-              element.isField ||
-              (element.isInitializingFormal &&
-                  compiler.options.enableInitializingFormalAccess),
+          element.isVariable || element.isParameter || element.isField,
           message: 'Unexpected context element ${element}'));
       return element.computeType(resolution);
     }
   }
 
   DartType visitIf(If node) {
     Expression condition = node.condition.expression;
     Statement thenPart = node.thenPart;
 
     checkCondition(node.condition);
@@ skipping 64 matching lines @@
     if (unaliasedBound.treatAsDynamic) {
       return new DynamicAccess();
     }
     InterfaceType interface =
         Types.computeInterfaceType(resolution, unaliasedBound);
     ElementAccess access = getAccess(memberName, unaliasedBound, interface);
     if (access != null) {
       return access;
     }
     if (receiverElement != null &&
-        (receiverElement.isVariable ||
-            receiverElement.isRegularParameter ||
-            (receiverElement.isInitializingFormal &&
-                compiler.options.enableInitializingFormalAccess))) {
+        (receiverElement.isVariable || receiverElement.isParameter)) {
       Link<TypePromotion> typePromotions = typePromotionsMap[receiverElement];
       if (typePromotions != null) {
         while (!typePromotions.isEmpty) {
           TypePromotion typePromotion = typePromotions.head;
           if (!typePromotion.isValid) {
             DartType unaliasedBound =
                 Types.computeUnaliasedBound(resolution, typePromotion.type);
             if (!unaliasedBound.treatAsDynamic) {
               InterfaceType interface =
                   Types.computeInterfaceType(resolution, unaliasedBound);
@@ skipping 296 matching lines @@
       return null;
     }
   }
 
   ElementAccess createResolvedAccess(Send node, String name, Element element) {
     checkPrivateAccess(node, element, name);
     return createPromotedAccess(element);
   }
 
   ElementAccess createPromotedAccess(Element element) {
-    if (element.isVariable ||
-        element.isRegularParameter ||
-        (element.isInitializingFormal &&
-            compiler.options.enableInitializingFormalAccess)) {
+    if (element.isVariable || element.isParameter) {
       TypePromotion typePromotion = getKnownTypePromotion(element);
       if (typePromotion != null) {
         return new PromotedAccess(element, typePromotion.type);
       }
     }
     return new ResolvedAccess(element);
   }
 
   /**
    * Computes the type of the access of [name] on the [node] possibly using the
@@ skipping 96 matching lines @@
           // Look for the variable element within parenthesized expressions.
           ParenthesizedExpression parentheses =
               node.receiver.asParenthesizedExpression();
           while (parentheses != null) {
             variable = elements[parentheses.expression];
             if (variable != null) break;
             parentheses = parentheses.expression.asParenthesizedExpression();
           }
         }
 
-        if (variable != null &&
-            (variable.isVariable ||
-                variable.isRegularParameter ||
-                (variable.isInitializingFormal &&
-                    compiler.options.enableInitializingFormalAccess))) {
+        if (variable != null && (variable.isVariable || variable.isParameter)) {
           DartType knownType = getKnownType(variable);
           if (!knownType.isDynamic) {
             DartType shownType = elements.getType(node.arguments.head);
             TypePromotion typePromotion =
                 new TypePromotion(node, variable, shownType);
             if (!types.isMoreSpecific(shownType, knownType)) {
               String variableName = variable.name;
               if (!types.isSubtype(shownType, knownType)) {
                 typePromotion.addHint(reporter.createMessage(
                     node, MessageKind.NOT_MORE_SPECIFIC_SUBTYPE, {
@@ skipping 814 matching lines @@
 
   visitTypedef(Typedef node) {
     // Do not typecheck [Typedef] nodes.
   }
 
   visitNode(Node node) {
     reporter.internalError(node,
         'Unexpected node ${node.getObjectDescription()} in the type checker.');
   }
 }