Skip class method type parameters and formal parameters.

pkg/analyzer/lib/src/task/dart.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 analyzer.src.task.dart;
 
 import 'dart:collection';
 
 import 'package:analyzer/dart/ast/ast.dart';
 import 'package:analyzer/dart/ast/token.dart';
@@ skipping 4646 matching lines @@
       } finally {
         dependsOn = null;
         scope = outerScope;
       }
     } else {
       super.visitFunctionTypeAlias(node);
     }
   }
 
   @override
+  visitMethodDeclaration(MethodDeclaration node) {
+    ReferencedNamesScope outerScope = scope;
+    try {
+      scope = new ReferencedNamesScope.forMethod(scope, node);
+      super.visitMethodDeclaration(node);
+    } finally {
+      scope = outerScope;
+    }
+  }
+
+  @override
   visitSimpleIdentifier(SimpleIdentifier node) {
     // Ignore all declarations.
     if (node.inDeclarationContext()) {
       return;
     }
     // Ignore class names references from constructors.
     AstNode parent = node.parent;
     if (parent is ConstructorDeclaration && parent.returnType == node) {
       return;
     }
@@ skipping 30 matching lines @@
       }
     }
     return scope;
   }
 
   factory ReferencedNamesScope.forClass(
       ReferencedNamesScope enclosing, ClassDeclaration node) {
     ReferencedNamesScope scope = new ReferencedNamesScope(enclosing);
     scope._addTypeParameters(node.typeParameters);
     for (ClassMember member in node.members) {
-      if (member is MethodDeclaration) {
+      if (member is FieldDeclaration) {
+        for (VariableDeclaration variable in member.fields.variables) {
+          scope.add(variable.name.name);
+        }
+      } else if (member is MethodDeclaration) {
         scope.add(member.name.name);
       }
     }
     return scope;
   }
 
   factory ReferencedNamesScope.forFunction(
       ReferencedNamesScope enclosing, FunctionDeclaration node) {
     ReferencedNamesScope scope = new ReferencedNamesScope(enclosing);
     scope._addTypeParameters(node.functionExpression.typeParameters);
-    node.functionExpression.parameters?.parameters
-        ?.map((p) => p is NormalFormalParameter ? p.identifier.name : '')
-        ?.forEach(scope.add);
+    scope._addFormalParameters(node.functionExpression.parameters);
     return scope;
   }
 
   factory ReferencedNamesScope.forFunctionTypeAlias(
       ReferencedNamesScope enclosing, FunctionTypeAlias node) {
     ReferencedNamesScope scope = new ReferencedNamesScope(enclosing);
     scope._addTypeParameters(node.typeParameters);
     return scope;
   }
 
+  factory ReferencedNamesScope.forMethod(
+      ReferencedNamesScope enclosing, MethodDeclaration node) {
+    ReferencedNamesScope scope = new ReferencedNamesScope(enclosing);
+    scope._addTypeParameters(node.typeParameters);
+    scope._addFormalParameters(node.parameters);
+    return scope;
+  }
+
   void add(String name) {
     names ??= new Set<String>();
     names.add(name);
   }
 
   bool contains(String name) {
     if (names != null && names.contains(name)) {
       return true;
     }
     if (enclosing != null) {
       return enclosing.contains(name);
     }
     return false;
   }
 
+  void _addFormalParameters(FormalParameterList parameterList) {
+    if (parameterList != null) {
+      parameterList.parameters
+          .map((p) => p is NormalFormalParameter ? p.identifier.name : '')
+          .forEach(add);
+    }
+  }
+
   void _addTypeParameters(TypeParameterList typeParameterList) {
     typeParameterList?.typeParameters?.map((p) => p.name.name)?.forEach(add);
   }
 }
 
 /**
  * A task that ensures that the expression AST for a constant is resolved and
  * sets the [CONSTANT_EXPRESSION_RESOLVED] result.
  */
 class ResolveConstantExpressionTask extends ConstantEvaluationAnalysisTask {
@@ skipping 1390 matching lines @@
 
   @override
   bool moveNext() {
     if (_newSources.isEmpty) {
       return false;
     }
     currentTarget = _newSources.removeLast();
     return true;
   }
 }