Add support to the task model for the @required annotation

pkg/analyzer/lib/src/generated/error_verifier.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.error_verifier;
 
 import 'dart:collection';
 import "dart:math" as math;
 
 import 'package:analyzer/dart/ast/ast.dart';
 import 'package:analyzer/dart/ast/token.dart';
 import 'package:analyzer/dart/ast/visitor.dart';
 import 'package:analyzer/dart/element/element.dart';
 import 'package:analyzer/dart/element/type.dart';
 import 'package:analyzer/dart/element/visitor.dart';
 import 'package:analyzer/src/dart/ast/utilities.dart';
 import 'package:analyzer/src/dart/element/element.dart';
 import 'package:analyzer/src/dart/element/member.dart';
 import 'package:analyzer/src/dart/element/type.dart';
 import 'package:analyzer/src/dart/resolver/inheritance_manager.dart';
+import 'package:analyzer/src/error/pending_error.dart';
 import 'package:analyzer/src/generated/constant.dart';
 import 'package:analyzer/src/generated/element_resolver.dart';
 import 'package:analyzer/src/generated/engine.dart';
 import 'package:analyzer/src/generated/error.dart';
 import 'package:analyzer/src/generated/java_engine.dart';
 import 'package:analyzer/src/generated/parser.dart' show ParserErrorCode;
 import 'package:analyzer/src/generated/resolver.dart';
 import 'package:analyzer/src/generated/sdk.dart' show DartSdk, SdkLibrary;
+import 'package:analyzer/src/generated/source.dart';
 import 'package:analyzer/src/generated/utilities_dart.dart';
+import 'package:analyzer/src/task/dart.dart';
 import 'package:analyzer/src/task/strong/info.dart' show StaticInfo;
 
 /**
  * A visitor used to traverse an AST structure looking for additional errors and
  * warnings not covered by the parser and resolver.
  */
 class ErrorVerifier extends RecursiveAstVisitor<Object> {
   /**
    * Static final string with value `"getter "` used in the construction of the
    * [StaticWarningCode.NON_ABSTRACT_CLASS_INHERITS_ABSTRACT_MEMBER_ONE], and
@@ skipping 782 matching lines @@
   Object visitInstanceCreationExpression(InstanceCreationExpression node) {
     bool wasInConstInstanceCreation = _isInConstInstanceCreation;
     _isInConstInstanceCreation = node.isConst;
     try {
       ConstructorName constructorName = node.constructorName;
       TypeName typeName = constructorName.type;
       DartType type = typeName.type;
       if (type is InterfaceType) {
         _checkForConstOrNewWithAbstractClass(node, typeName, type);
         _checkForConstOrNewWithEnum(node, typeName, type);
-        _checkForMissingRequiredParam(
-            node.staticElement?.type, node.argumentList, node.constructorName);
         if (_isInConstInstanceCreation) {
           _checkForConstWithNonConst(node);
           _checkForConstWithUndefinedConstructor(
               node, constructorName, typeName);
           _checkForConstWithTypeParameters(typeName);
           _checkForConstDeferredClass(node, constructorName, typeName);
         } else {
           _checkForNewWithUndefinedConstructor(node, constructorName, typeName);
         }
       }
@@ skipping 91 matching lines @@
   Object visitMethodInvocation(MethodInvocation node) {
     Expression target = node.realTarget;
     SimpleIdentifier methodName = node.methodName;
     if (target != null) {
       ClassElement typeReference = ElementResolver.getTypeReference(target);
       _checkForStaticAccessToInstanceMember(typeReference, methodName);
       _checkForInstanceAccessToStaticMember(typeReference, methodName);
     } else {
       _checkForUnqualifiedReferenceToNonLocalStaticMember(methodName);
     }
-    _checkForMissingRequiredParam(
-        node.staticInvokeType, node.argumentList, methodName);
     _checkTypeArguments(
         node.methodName.staticElement, node.typeArguments, target?.staticType);
     return super.visitMethodInvocation(node);
   }
 
   @override
   Object visitNativeClause(NativeClause node) {
     // TODO(brianwilkerson) Figure out the right rule for when 'native' is
     // allowed.
     if (!_isInSystemLibrary) {
@@ skipping 3282 matching lines @@
   void _checkForMissingJSLibAnnotation(Annotation node) {
     if (node.elementAnnotation?.isJS ?? false) {
       Element element = ElementLocator.locate(node.parent);
       if (element?.library?.isJS != true) {
         _errorReporter.reportErrorForNode(
             HintCode.MISSING_JS_LIB_ANNOTATION, node, [element.name]);
       }
     }
   }
 
-  void _checkForMissingRequiredParam(
-      DartType type, ArgumentList argumentList, AstNode node) {
-    if (type is FunctionType) {
-      List<ParameterElement> parameters = type.parameters;
-      for (ParameterElement param in parameters) {
-        if (param.parameterKind == ParameterKind.NAMED) {
-          ElementAnnotationImpl annotation = _getRequiredAnnotation(param);
-          if (annotation != null) {
-            String paramName = param.name;
-            if (!_containsNamedExpression(argumentList, paramName)) {
-              DartObject constantValue = annotation.constantValue;
-              String reason =
-                  constantValue?.getField('reason')?.toStringValue();
-              if (reason != null) {
-                _errorReporter.reportErrorForNode(
-                    HintCode.MISSING_REQUIRED_PARAM_WITH_DETAILS,
-                    node,
-                    [paramName, reason]);
-              } else {
-                _errorReporter.reportErrorForNode(
-                    HintCode.MISSING_REQUIRED_PARAM, node, [paramName]);
-              }
-            }
-          }
-        }
-      }
-    }
-  }
-
   /**
    * Verify that the given function [body] does not contain return statements
    * that both have and do not have return values.
    *
    * See [StaticWarningCode.MIXED_RETURN_TYPES].
    */
   void _checkForMixedReturns(BlockFunctionBody body) {
     if (_hasReturnWithoutValue) {
       return;
     }
@@ skipping 1466 matching lines @@
       }
     }
     DartType staticReturnType = getStaticType(returnExpression);
     if (staticReturnType != null && _enclosingFunction.isAsynchronous) {
       return _typeProvider.futureType.instantiate(
           <DartType>[staticReturnType.flattenFutures(_typeSystem)]);
     }
     return staticReturnType;
   }
 
-  bool _containsNamedExpression(ArgumentList args, String name) {
-    for (Expression expression in args.arguments) {
-      if (expression is NamedExpression) {
-        if (expression.name.label.name == name) {
-          return true;
-        }
-      }
-    }
-    return false;
-  }
-
   bool _expressionIsAssignableAtType(Expression expression,
       DartType actualStaticType, DartType expectedStaticType) {
     bool concrete =
         _options.strongMode && StaticInfo.isKnownFunction(expression);
     if (concrete) {
       actualStaticType =
           _typeSystem.typeToConcreteType(_typeProvider, actualStaticType);
       // TODO(leafp): Move the Downcast functionality here.
       // TODO(leafp): Support strict downcasts
     }
@@ skipping 73 matching lines @@
     }
 
     ClassElement classElement =
         member.getAncestor((element) => element is ClassElement);
     if (classElement == null) {
       return null;
     }
     return _inheritanceManager.lookupInheritance(classElement, member.name);
   }
 
-  ElementAnnotationImpl _getRequiredAnnotation(ParameterElement param) => param
-      .metadata
-      .firstWhere((ElementAnnotation e) => e.isRequired, orElse: () => null);
-
   /**
    * Return the type of the first and only parameter of the given [setter].
    */
   DartType _getSetterType(PropertyAccessorElement setter) {
     // Get the parameters for MethodDeclaration or FunctionDeclaration
     List<ParameterElement> setterParameters = setter.parameters;
     // If there are no setter parameters, return no type.
     if (setterParameters.length == 0) {
       return null;
     }
@@ skipping 340 matching lines @@
     // type arguments
     if (type is InterfaceType) {
       for (DartType typeArgument in type.typeArguments) {
         _addTypeToCheck(typeArgument);
       }
     }
   }
 }
 
 /**
+ * A class used to compute a list of the constants whose value needs to be
+ * computed before errors can be computed by the [VerifyUnitTask].
+ */
+class RequiredConstantsComputer extends RecursiveAstVisitor {
+  /**
+   * The source with which any pending errors will be associated.
+   */
+  final Source source;
+
+  /**
+   * A list of the pending errors that were computed.
+   */
+  final List<PendingError> pendingErrors = <PendingError>[];
+
+  /**
+   * A list of the constants whose value needs to be computed before the pending
+   * errors can be used to compute an analysis error.
+   */
+  final List<ConstantEvaluationTarget> requiredConstants =
+      <ConstantEvaluationTarget>[];
+
+  /**
+   * Initialize a newly created computer to compute required constants within
+   * the given [source].
+   */
+  RequiredConstantsComputer(this.source);
+
+  @override
+  Object visitInstanceCreationExpression(InstanceCreationExpression node) {
+    DartType type = node.constructorName.type.type;
+    if (type is InterfaceType) {
+      _checkForMissingRequiredParam(
+          node.staticElement?.type, node.argumentList, node.constructorName);
+    }
+    return super.visitInstanceCreationExpression(node);
+  }
+
+  @override
+  Object visitMethodInvocation(MethodInvocation node) {
+    _checkForMissingRequiredParam(
+        node.staticInvokeType, node.argumentList, node.methodName);
+    return super.visitMethodInvocation(node);
+  }
+
+  void _checkForMissingRequiredParam(
+      DartType type, ArgumentList argumentList, AstNode node) {
+    if (type is FunctionType) {
+      for (ParameterElement parameter in type.parameters) {
+        if (parameter.parameterKind == ParameterKind.NAMED) {
+          ElementAnnotationImpl annotation = _getRequiredAnnotation(parameter);
+          if (annotation != null) {
+            String parameterName = parameter.name;
+            if (!_containsNamedExpression(argumentList, parameterName)) {
+              requiredConstants.add(annotation);
+              pendingErrors.add(new PendingMissingRequiredParameterError(
+                  source, parameterName, node, annotation));
+            }
+          }
+        }
+      }
+    }
+  }
+
+  bool _containsNamedExpression(ArgumentList args, String name) {
+    NodeList<Expression> arguments = args.arguments;
+    for (int i = arguments.length - 1; i >= 0; i--) {
+      Expression expression = arguments[i];
+      if (expression is NamedExpression) {
+        if (expression.name.label.name == name) {
+          return true;
+        }
+      }
+    }
+    return false;
+  }
+
+  ElementAnnotationImpl _getRequiredAnnotation(ParameterElement param) => param
+      .metadata
+      .firstWhere((ElementAnnotation e) => e.isRequired, orElse: () => null);
+}
+
+/**
  * Recursively visits an AST, looking for method invocations.
  */
 class _InvocationCollector extends RecursiveAstVisitor {
   final List<String> superCalls = <String>[];
 
   @override
   visitMethodInvocation(MethodInvocation node) {
     if (node.target is SuperExpression) {
       superCalls.add(node.methodName.name);
     }
   }
 }