Add support for accessing field formal parameters in the initializer list of constructors

pkg/analyzer/lib/src/generated/resolver.dart

 // Copyright (c) 2014, 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 analyzer.src.generated.resolver;
 
 import 'dart:collection';
 
 import 'package:analyzer/dart/ast/ast.dart';
 import 'package:analyzer/dart/ast/token.dart';
@@ skipping 6330 matching lines @@
     }
     ConstructorElementImpl constructor = node.element;
     constructor.constantInitializers =
         new ConstantAstCloner().cloneNodeList(node.initializers);
     return null;
   }
 
   @override
   void visitConstructorDeclarationInScope(ConstructorDeclaration node) {
     super.visitConstructorDeclarationInScope(node);
+    // Because of needing a different scope for the initializer list, the
+    // overridden implementation of this method cannot cause the visitNode
+    // method to be invoked. As a result, we have to hard-code using the
+    // element resolver and type analyzer to visit the constructor declaration.
+    node.accept(elementResolver);
+    node.accept(typeAnalyzer);
     safelyVisitComment(node.documentationComment);
   }
 
   @override
   Object visitConstructorFieldInitializer(ConstructorFieldInitializer node) {
     //
     // We visit the expression, but do not visit the field name because it needs
     // to be visited in the context of the constructor field initializer node.
     //
     FieldElement fieldElement = enclosingClass.getField(node.fieldName.name);
@@ skipping 1376 matching lines @@
    */
   ImplicitLabelScope _implicitLabelScope = ImplicitLabelScope.ROOT;
 
   /**
    * The scope used to resolve labels for `break` and `continue` statements, or
    * `null` if no labels have been defined in the current context.
    */
   LabelScope labelScope;
 
   /**
+   * A flag indicating whether to enable support for allowing access to field
+   * formal parameters in a constructor's initializer list.
+   */
+  bool enableInitializingFormalAccess = false;
+
+  /**
    * The class containing the AST nodes being visited,
    * or `null` if we are not in the scope of a class.
    */
   ClassElement enclosingClass;
 
   /**
    * Initialize a newly created visitor to resolve the nodes in a compilation
    * unit.
    *
    * [definingLibrary] is the element for the library containing the
@@ skipping 10 matching lines @@
   ScopedVisitor(this.definingLibrary, Source source, this.typeProvider,
       AnalysisErrorListener errorListener,
       {Scope nameScope})
       : source = source,
         errorReporter = new ErrorReporter(errorListener, source) {
     if (nameScope == null) {
       this.nameScope = new LibraryScope(definingLibrary);
     } else {
       this.nameScope = nameScope;
     }
+    enableInitializingFormalAccess =
+        definingLibrary.context.analysisOptions.enableInitializingFormalAccess;
   }
 
   /**
    * Return the implicit label scope in which the current node is being
    * resolved.
    */
   ImplicitLabelScope get implicitLabelScope => _implicitLabelScope;
 
   /**
    * Replaces the current [Scope] with the enclosing [Scope].
@@ skipping 116 matching lines @@
       super.visitClassTypeAlias(node);
     } finally {
       nameScope = outerScope;
     }
     return null;
   }
 
   @override
   Object visitConstructorDeclaration(ConstructorDeclaration node) {
     ConstructorElement constructorElement = node.element;
+    if (constructorElement == null) {
+      StringBuffer buffer = new StringBuffer();
+      buffer.write("Missing element for constructor ");
+      buffer.write(node.returnType.name);
+      if (node.name != null) {
+        buffer.write(".");
+        buffer.write(node.name.name);
+      }
+      buffer.write(" in ");
+      buffer.write(definingLibrary.source.fullName);
+      AnalysisEngine.instance.logger.logInformation(buffer.toString(),
+          new CaughtException(new AnalysisException(), null));
+    }
     Scope outerScope = nameScope;
     try {
-      if (constructorElement == null) {
-        StringBuffer buffer = new StringBuffer();
-        buffer.write("Missing element for constructor ");
-        buffer.write(node.returnType.name);
-        if (node.name != null) {
-          buffer.write(".");
-          buffer.write(node.name.name);
-        }
-        buffer.write(" in ");
-        buffer.write(definingLibrary.source.fullName);
-        AnalysisEngine.instance.logger.logInformation(buffer.toString(),
-            new CaughtException(new AnalysisException(), null));
-      } else {
+      if (constructorElement != null) {
         nameScope = new FunctionScope(nameScope, constructorElement);
       }
+      node.documentationComment?.accept(this);
+      node.metadata.accept(this);
+      node.returnType?.accept(this);
+      node.name?.accept(this);
+      node.parameters?.accept(this);
+      Scope functionScope = nameScope;
+      try {
+        if (constructorElement != null && enableInitializingFormalAccess) {
+          nameScope =
+              new ConstructorInitializerScope(nameScope, constructorElement);
+        }
+        node.initializers.accept(this);
+      } finally {
+        nameScope = functionScope;
+      }
+      node.redirectedConstructor?.accept(this);
       visitConstructorDeclarationInScope(node);
     } finally {
       nameScope = outerScope;
     }
     return null;
   }
 
   void visitConstructorDeclarationInScope(ConstructorDeclaration node) {
-    super.visitConstructorDeclaration(node);
+    node.body?.accept(this);
   }
 
   @override
   Object visitDeclaredIdentifier(DeclaredIdentifier node) {
     VariableElement element = node.element;
     if (element != null) {
       nameScope.define(element);
     }
     super.visitDeclaredIdentifier(node);
     return null;
@@ skipping 3209 matching lines @@
       return null;
     }
     if (identical(node.staticElement, variable)) {
       if (node.inSetterContext()) {
         result = true;
       }
     }
     return null;
   }
 }