New tests for initializing formal access.

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 663 matching lines @@
   DartType visitIdentifier(Identifier node) {
     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.isParameter || element.isField,
+          node,
+          element.isVariable ||
+              element.isParameter ||
+              element.isField ||
+              (element.isInitializingFormal &&
+                  compiler.options.enableInitializingFormalAccess),
           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 60 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.isParameter)) {
+        (receiverElement.isVariable || receiverElement.isParameter ||
+            (receiverElement.isInitializingFormal &&
+                compiler.options.enableInitializingFormalAccess))) {
       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 295 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.isParameter) {
+    if (element.isVariable || element.isParameter ||
+        (element.isInitializingFormal &&
+            compiler.options.enableInitializingFormalAccess)) {
       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 114 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.isParameter)) {
+        if (variable != null &&
+            (variable.isVariable ||
+                variable.isParameter ||
+                (variable.isInitializingFormal &&
+                    compiler.options.enableInitializingFormalAccess))) {
           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 799 matching lines @@
 
   visitTypedef(Typedef node) {
     // Do not typecheck [Typedef] nodes.
   }
 
   visitNode(Node node) {
     reporter.internalError(node,
         'Unexpected node ${node.getObjectDescription()} in the type checker.');
   }
 }