[fasta] Handle annotations on formals of typedefs

Fixes #33799.

Bug: http://dartbug.com/33799
Change-Id: I5808e45839cece468d890dcaf344df0d4b249a3c
Reviewed-on: https://dart-review.googlesource.com/65701
Commit-Queue: Dmitry Stefantsov <[email protected]>
Reviewed-by: Jens Johansen <[email protected]>
Reviewed-by: Konstantin Shcheglov <[email protected]>
Reviewed-by: Dan Rubel <[email protected]>

Author: Dmitry Stefantsov

pkg/front_end/lib/src/fasta/kernel/body_builder.dart

@@ -855,6 +855,14 @@ abstract class BodyBuilder extends ScopeListener<JumpTarget>
   List<Expression> finishMetadata(TreeNode parent) {
     List<Expression> expressions = pop();
     _typeInferrer.inferMetadata(this, expressions);
+
+    // The invocation of [resolveRedirectingFactoryTargets] below may change the
+    // root nodes of the annotation expressions.  We need to have a parent of
+    // the annotation nodes before the resolution is performed, to collect and
+    // return them later.  If [parent] is not provided, [temporaryParent] is
+    // used.
+    ListLiteral temporaryParent;
+
     if (parent is Class) {
       for (Expression expression in expressions) {
         parent.addAnnotation(expression);
@@ -887,9 +895,11 @@ abstract class BodyBuilder extends ScopeListener<JumpTarget>
       for (Expression expression in expressions) {
         parent.addAnnotation(expression);
       }
+    } else {
+      temporaryParent = new ListLiteral(expressions);
     }
     resolveRedirectingFactoryTargets();
-    return expressions;
+    return temporaryParent != null ? temporaryParent.expressions : expressions;
   }
 
   @override

pkg/front_end/lib/src/fasta/source/diet_listener.dart

@@ -13,7 +13,8 @@ import 'package:kernel/ast.dart'
         LibraryDependency,
         LibraryPart,
         Node,
-        TreeNode;
+        TreeNode,
+        VariableDeclaration;
 
 import 'package:kernel/class_hierarchy.dart' show ClassHierarchy;
 
@@ -35,6 +36,12 @@ import '../fasta_codes.dart'
 
 import '../kernel/kernel_body_builder.dart' show KernelBodyBuilder;
 
+import '../kernel/kernel_formal_parameter_builder.dart'
+    show KernelFormalParameterBuilder;
+
+import '../kernel/kernel_function_type_alias_builder.dart'
+    show KernelFunctionTypeAliasBuilder;
+
 import '../kernel/kernel_procedure_builder.dart'
     show KernelRedirectingFactoryBuilder;
 
@@ -220,6 +227,38 @@ class DietListener extends StackListener {
 
     Declaration typedefBuilder = lookupBuilder(typedefKeyword, null, name);
     parseMetadata(typedefBuilder, metadata, typedefBuilder.target);
+    if (typedefBuilder is KernelFunctionTypeAliasBuilder &&
+        typedefBuilder.type != null &&
+        typedefBuilder.type.formals != null) {
+      for (int i = 0; i < typedefBuilder.type.formals.length; ++i) {
+        KernelFormalParameterBuilder formal = typedefBuilder.type.formals[i];
+        List<MetadataBuilder> metadata = formal.metadata;
+        if (metadata != null && metadata.length > 0) {
+          // [parseMetadata] is using [Parser.parseMetadataStar] under the hood,
+          // so we only need the offset of the first annotation.
+          Token metadataToken =
+              tokenForOffset(typedefKeyword, endToken, metadata[0].charOffset);
+          List<Expression> annotations =
+              parseMetadata(typedefBuilder, metadataToken, null);
+          if (formal.isPositional) {
+            VariableDeclaration parameter =
+                typedefBuilder.target.positionalParameters[i];
+            for (Expression annotation in annotations) {
+              parameter.addAnnotation(annotation);
+            }
+          } else {
+            for (VariableDeclaration named
+                in typedefBuilder.target.namedParameters) {
+              if (named.name == formal.name) {
+                for (Expression annotation in annotations) {
+                  named.addAnnotation(annotation);
+                }
+              }
+            }
+          }
+        }
+      }
+    }
 
     checkEmpty(typedefKeyword.charOffset);
   }
@@ -833,6 +872,22 @@ class DietListener extends StackListener {
     return null;
   }
 
+  /// Returns [Token] found between [start] (inclusive) and [end]
+  /// (non-inclusive) that has its [Token.charOffset] equal to [offset].  If
+  /// there is no such token, null is returned.
+  Token tokenForOffset(Token start, Token end, int offset) {
+    if (offset < start.charOffset || offset >= end.charOffset) {
+      return null;
+    }
+    while (start != end) {
+      if (offset == start.charOffset) {
+        return start;
+      }
+      start = start.next;
+    }
+    return null;
+  }
+
   /// Returns list of [Token]s found between [start] (inclusive) and [end]
   /// (non-inclusive) that correspond to [offsets].  If there's no token between
   /// [start] and [end] for the given offset, the corresponding item in the

pkg/front_end/testcases/annotation_typedef_formals.dart

@@ -0,0 +1,15 @@
+// Copyright (c) 2018, 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.
+
+// This test checks that the compiler handles annotations on formals of
+// typedefs.
+
+const int foo = 21;
+const int bar = 42;
+const int baz = 84;
+
+typedef void F(@foo int x, num y, {@bar @baz String z, Object w});
+typedef void G(@foo int a, num b, [@bar @baz String c, Object d]);
+
+main() {}

pkg/front_end/testcases/annotation_typedef_formals.dart.direct.expect

@@ -0,0 +1,10 @@
+library;
+import self as self;
+import "dart:core" as core;
+
+typedef F = (@self::foo core::int x, core::num y, {@self::bar @self::baz core::String z, core::Object w}) → void;
+typedef G = (@self::foo core::int a, core::num b, [@self::bar @self::baz core::String c, core::Object d]) → void;
+static const field core::int foo = 21;
+static const field core::int bar = 42;
+static const field core::int baz = 84;
+static method main() → dynamic {}

pkg/front_end/testcases/annotation_typedef_formals.dart.direct.transformed.expect

@@ -0,0 +1,10 @@
+library;
+import self as self;
+import "dart:core" as core;
+
+typedef F = (@self::foo core::int x, core::num y, {@self::bar @self::baz core::String z, core::Object w}) → void;
+typedef G = (@self::foo core::int a, core::num b, [@self::bar @self::baz core::String c, core::Object d]) → void;
+static const field core::int foo = 21;
+static const field core::int bar = 42;
+static const field core::int baz = 84;
+static method main() → dynamic {}

pkg/front_end/testcases/annotation_typedef_formals.dart.outline.expect

@@ -0,0 +1,11 @@
+library;
+import self as self;
+import "dart:core" as core;
+
+typedef F = (core::int, core::num, {w: core::Object, z: core::String}) → void;
+typedef G = (core::int, core::num, [core::String, core::Object]) → void;
+static const field core::int foo;
+static const field core::int bar;
+static const field core::int baz;
+static method main() → dynamic
+  ;

pkg/front_end/testcases/annotation_typedef_formals.dart.strong.expect

@@ -0,0 +1,10 @@
+library;
+import self as self;
+import "dart:core" as core;
+
+typedef F = (@self::foo core::int x, core::num y, {@self::bar @self::baz core::String z, core::Object w}) → void;
+typedef G = (@self::foo core::int a, core::num b, [@self::bar @self::baz core::String c, core::Object d]) → void;
+static const field core::int foo = 21;
+static const field core::int bar = 42;
+static const field core::int baz = 84;
+static method main() → dynamic {}

pkg/front_end/testcases/annotation_typedef_formals.dart.strong.transformed.expect

@@ -0,0 +1,10 @@
+library;
+import self as self;
+import "dart:core" as core;
+
+typedef F = (@self::foo core::int x, core::num y, {@self::bar @self::baz core::String z, core::Object w}) → void;
+typedef G = (@self::foo core::int a, core::num b, [@self::bar @self::baz core::String c, core::Object d]) → void;
+static const field core::int foo = 21;
+static const field core::int bar = 42;
+static const field core::int baz = 84;
+static method main() → dynamic {}

pkg/front_end/testcases/annotation_typedef_formals_resolution.dart

@@ -0,0 +1,13 @@
+// Copyright (c) 2018, 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.
+
+// This test checks that the annotation on a formal parameter of a typedef is
+// resolved to the top-level constant, and not to the parameter itself in case
+// of a name match.
+
+const int app = 0;
+
+typedef int F(@app int app);
+
+main() {}

pkg/front_end/testcases/annotation_typedef_formals_resolution.dart.direct.expect

@@ -0,0 +1,7 @@
+library;
+import self as self;
+import "dart:core" as core;
+
+typedef F = (@self::app core::int app) → core::int;
+static const field core::int app = 0;
+static method main() → dynamic {}