Record names of classes which unnamed constructor are used in SuperConstructorInvocation.

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 2638 matching lines @@
     // TODO(scheglov) Use only instantiations with default constructor.
     for (String name in references.instantiatedNames) {
       for (ClassElementDelta classDelta in changedClasses.values) {
         if (classDelta.name == name && classDelta.hasUnnamedConstructorChange) {
           _log(() =>
               '$refLibrary is affected by the default constructor of $name');
           return true;
         }
       }
     }
+    for (String name in references.extendedUsedUnnamedConstructorNames) {
+      for (ClassElementDelta classDelta in changedClasses.values) {
+        if (classDelta.name == name && classDelta.hasUnnamedConstructorChange) {
+          _log(() =>
+              '$refLibrary is affected by the default constructor of $name');
+          return true;
+        }
+      }
+    }
     return false;
   }
 
   /**
    * Return `true` if the given [name], used in a unit of the [librarySource],
    * is affected by a changed top-level element, excluding classes.
    */
   bool isChanged(Source librarySource, String name) {
     if (_isPrivateName(name)) {
       if (changedPrivateNames[librarySource]?.contains(name) ?? false) {
@@ skipping 2112 matching lines @@
    * that extend, mix-in, or implement it.
    *
    * If the set of member of a class is changed, these changes might change
    * the list of unimplemented inherited members in the class and classes that
    * extend, mix-in, or implement it. So, we might need to report (or stop
    * reporting) the corresponding warning.
    */
   final Map<String, Set<String>> superToSubs = <String, Set<String>>{};
 
   /**
+   * The names of extended classes for which the unnamed constructor is
+   * invoked. Because we cannot use the name of the constructor to identify
+   * whether the unit is affected, we need to use the class name.
+   */
+  final Set<String> extendedUsedUnnamedConstructorNames = new Set<String>();
+
+  /**
    * The names of instantiated classes.
    *
    * If one of these classes changes its set of members, it might change
    * its list of unimplemented inherited members. So, we might need to report
    * (or stop reporting) the corresponding warning.
    */
   final Set<String> instantiatedNames = new Set<String>();
 
   /**
    * The set of names that are referenced by the library, both inside and
@@ skipping 15 matching lines @@
   }
 }
 
 /**
  * A builder for creating [ReferencedNames].
  */
 class ReferencedNamesBuilder extends GeneralizingAstVisitor {
   final Set<String> importPrefixNames = new Set<String>();
   final ReferencedNames names;
 
+  String enclosingSuperClassName;
   ReferencedNamesScope scope = new ReferencedNamesScope(null);
 
   int localLevel = 0;
   Set<String> dependsOn;
 
   ReferencedNamesBuilder(this.names);
 
   ReferencedNames build(CompilationUnit unit) {
     unit.accept(this);
     return names;
   }
 
   @override
   visitBlock(Block node) {
     ReferencedNamesScope outerScope = scope;
     try {
       scope = new ReferencedNamesScope.forBlock(scope, node);
       super.visitBlock(node);
     } finally {
       scope = outerScope;
     }
   }
 
   @override
   visitClassDeclaration(ClassDeclaration node) {
     ReferencedNamesScope outerScope = scope;
     try {
       scope = new ReferencedNamesScope.forClass(scope, node);
       dependsOn = new Set<String>();
+      enclosingSuperClassName =
+          _getSimpleName(node.extendsClause?.superclass?.name);
       super.visitClassDeclaration(node);
       String className = node.name.name;
       names.userToDependsOn[className] = dependsOn;
       _addSuperName(className, node.extendsClause?.superclass);
       _addSuperNames(className, node.withClause?.mixinTypes);
       _addSuperNames(className, node.implementsClause?.interfaces);
     } finally {
+      enclosingSuperClassName = null;
       dependsOn = null;
       scope = outerScope;
     }
   }
 
+  static String _getSimpleName(Identifier identifier) {
+    if (identifier is SimpleIdentifier) {
+      return identifier.name;
+    }
+    if (identifier is PrefixedIdentifier) {
+      return identifier.identifier.name;
+    }
+    return null;
+  }
+
   @override
   visitClassTypeAlias(ClassTypeAlias node) {
     ReferencedNamesScope outerScope = scope;
     try {
       scope = new ReferencedNamesScope.forClassTypeAlias(scope, node);
       dependsOn = new Set<String>();
       super.visitClassTypeAlias(node);
       String className = node.name.name;
       names.userToDependsOn[className] = dependsOn;
       _addSuperName(className, node.superclass);
       _addSuperNames(className, node.withClause?.mixinTypes);
       _addSuperNames(className, node.implementsClause?.interfaces);
     } finally {
       dependsOn = null;
       scope = outerScope;
     }
   }
 
   @override
   visitComment(Comment node) {
     try {
       localLevel++;
       super.visitComment(node);
     } finally {
       localLevel--;
     }
   }
 
   @override
+  visitSuperConstructorInvocation(SuperConstructorInvocation node) {
+    if (node.constructorName == null && enclosingSuperClassName != null) {
+      names.extendedUsedUnnamedConstructorNames.add(enclosingSuperClassName);
+    }
+    super.visitSuperConstructorInvocation(node);
+  }
+
+  @override
   visitConstructorName(ConstructorName node) {
     if (node.parent is! ConstructorDeclaration) {
       super.visitConstructorName(node);
     }
   }
 
   @override
   visitFunctionBody(FunctionBody node) {
     try {
       localLevel++;
@@ skipping 1618 matching lines @@
 
   @override
   bool moveNext() {
     if (_newSources.isEmpty) {
       return false;
     }
     currentTarget = _newSources.removeLast();
     return true;
   }
 }