Validation of `@required` params (#26182).

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';
@@ skipping 800 matching lines @@
     bool wasInConstInstanceCreation = _isInConstInstanceCreation;
     _isInConstInstanceCreation = node.isConst;
     try {
       ConstructorName constructorName = node.constructorName;
       TypeName typeName = constructorName.type;
       DartType type = typeName.type;
       if (type is InterfaceType) {
         InterfaceType interfaceType = type;
         _checkForConstOrNewWithAbstractClass(node, typeName, interfaceType);
         _checkForConstOrNewWithEnum(node, typeName, interfaceType);
+        _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);
     return super.visitMethodInvocation(node);
   }
 
   @override
   Object visitNativeClause(NativeClause node) {
     // TODO(brianwilkerson) Figure out the right rule for when 'native' is
     // allowed.
     if (!_isInSystemLibrary) {
       _errorReporter.reportErrorForNode(
           ParserErrorCode.NATIVE_CLAUSE_IN_NON_SDK_CODE, node);
@@ skipping 2776 matching lines @@
     if (!executableElement.isStatic) {
       return;
     }
 
     _errorReporter.reportErrorForNode(
         StaticTypeWarningCode.INSTANCE_ACCESS_TO_STATIC_MEMBER,
         name,
         [name.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)) {
+              String reason = '';
+              DartObject constantValue = annotation.constantValue;
+              reason ??= constantValue.getField('reason')?.toStringValue();

[Brian Wilkerson, 2016/04/05 23:27:35]

reason will never be null at this point, so I think the assignment will never
happen. I think what you want is

String reason = constantValue.getField('reason')?.toStringValue() ?? '';

[pquitslund, 2016/04/06 00:04:13]

Right.  Thanks for catching that.

+              // Append a `.` if needed.
+              if (reason != null &&
+                  reason.isNotEmpty &&
+                  !reason.endsWith('.')) {
+                reason += '.';
+              }
+
+              _errorReporter.reportErrorForNode(
+                  HintCode.MISSING_REQUIRED_PARAM, node, [paramName, reason]);
+            }
+          }
+        }
+      }
+    }
+  }
+
+  ElementAnnotationImpl _getRequiredAnnotation(ParameterElement param) => param
+      .metadata
+      .firstWhere((ElementAnnotation e) => e.isRequired, orElse: () => null);
+
+  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;
+  }
+
   /**
    * Check whether the given [executableElement] collides with the name of a
    * static method in one of its superclasses, and reports the appropriate
    * warning if it does. The [errorNameTarget] is the node to report problems
    * on.
    *
    * See [StaticTypeWarningCode.INSTANCE_METHOD_NAME_COLLIDES_WITH_SUPERCLASS_STATIC].
    */
   bool _checkForInstanceMethodNameCollidesWithSuperclassStatic(
       ExecutableElement executableElement, SimpleIdentifier errorNameTarget) {
@@ skipping 2324 matching lines @@
 class _InvocationCollector extends RecursiveAstVisitor {
   final List<String> superCalls = <String>[];
 
   @override
   visitMethodInvocation(MethodInvocation node) {
     if (node.target is SuperExpression) {
       superCalls.add(node.methodName.name);
     }
   }
 }