Allow Stream<T> and subtypes of it in outputs, refs #76 (#89)

* Allow Stream<T> and subtypes of it in outputs, refs #76

Use the mostSpecificTypeArgument method API to get the stream type
regardless of the inheritance tree and generics defined within it.

Plus style fixes including in some old code

Author: MichaelRFairhurst

analyzer_plugin/lib/src/tasks.dart

@@ -228,6 +228,7 @@ class BuildStandardHtmlComponentsTask extends AnalysisTask {
 class BuildUnitDirectivesTask extends SourceBasedAnalysisTask
     with _AnnotationProcessorMixin {
   static const String UNIT_INPUT = 'UNIT_INPUT';
+  static const String TYPE_PROVIDER_INPUT = 'TYPE_PROVIDER_INPUT';
 
   static final TaskDescriptor DESCRIPTOR = new TaskDescriptor(
       'BuildUnitDirectivesTask',
@@ -241,8 +242,11 @@ class BuildUnitDirectivesTask extends SourceBasedAnalysisTask
   @override
   TaskDescriptor get descriptor => DESCRIPTOR;
 
+  TypeProvider typeProvider;
+
   @override
   void internalPerform() {
+    typeProvider = getRequiredInput(TYPE_PROVIDER_INPUT);
     initAnnotationProcessor(target);
     //
     // Prepare inputs.
@@ -435,11 +439,13 @@ class BuildUnitDirectivesTask extends SourceBasedAnalysisTask
 
   DartType getEventType(PropertyAccessorElement getter, String name) {
     if (getter != null && getter.type != null) {
-      var returntype = getter.type.returnType;
-      if (returntype != null && returntype is InterfaceType) {
-        // TODO allow subtypes of EventEmitter
-        if (returntype.element.name == 'EventEmitter') {
-          return returntype.typeArguments[0]; // may be null
+      var returnType = getter.type.returnType;
+      if (returnType != null && returnType is InterfaceType) {
+        dart.DartType streamType = typeProvider.streamType;
+        dart.DartType streamedType =
+            context.typeSystem.mostSpecificTypeArgument(returnType, streamType);
+        if (streamedType != null) {
+          return streamedType;
         } else {
           errorReporter.reportErrorForNode(
               AngularWarningCode.OUTPUT_MUST_BE_EVENTEMITTER,
@@ -454,7 +460,7 @@ class BuildUnitDirectivesTask extends SourceBasedAnalysisTask
       }
     }
 
-    return null;
+    return typeProvider.dynamicType;
   }
 
   List<InputElement> _parseHeaderInputs(
@@ -650,7 +656,10 @@ class BuildUnitDirectivesTask extends SourceBasedAnalysisTask
    * given [target].
    */
   static Map<String, TaskInput> buildInputs(LibrarySpecificUnit target) {
-    return <String, TaskInput>{UNIT_INPUT: RESOLVED_UNIT.of(target)};
+    return <String, TaskInput>{
+      UNIT_INPUT: RESOLVED_UNIT.of(target),
+      TYPE_PROVIDER_INPUT: TYPE_PROVIDER.of(AnalysisContextTarget.request)
+    };
   }
 
   /**
@@ -1381,18 +1390,18 @@ class _BuildStandardHtmlComponentsVisitor extends RecursiveAstVisitor {
 
       if (!outputMap.containsKey(name)) {
         if (accessor.isGetter) {
-          var returntype =
+          var returnType =
               accessor.type == null ? null : accessor.type.returnType;
-          DartType eventtype = null;
-          if (returntype != null && returntype is InterfaceType) {
+          DartType eventType = null;
+          if (returnType != null && returnType is InterfaceType) {
             // TODO allow subtypes of ElementStream? This is a generated file
             // so might not be necessary.
-            if (returntype.element.name == 'ElementStream') {
-              eventtype = returntype.typeArguments[0]; // may be null
+            if (returnType.element.name == 'ElementStream') {
+              eventType = returnType.typeArguments[0]; // may be null
             }
           }
           outputMap[name] = new OutputElement(name, accessor.nameOffset,
-              accessor.nameLength, accessor.source, accessor, null, eventtype);
+              accessor.nameLength, accessor.source, accessor, null, eventType);
         }
       }
     });

analyzer_plugin/test/tasks_test.dart

@@ -620,12 +620,135 @@ class MyComponent {
     errorListener.assertNoErrors();
   }
 
+  void test_outputs_streamIsOk() {
+    String code = r'''
+import '/angular2/angular2.dart';
+import 'dart:async';
+
+@Component(
+    selector: 'my-component',
+    template: '<p></p>')
+class MyComponent {
+  @Output()
+  Stream<int> myOutput;
+}
+''';
+    Source source = newSource('/test.dart', code);
+    LibrarySpecificUnit target = new LibrarySpecificUnit(source, source);
+    computeResult(target, DIRECTIVES_IN_UNIT);
+    expect(task, new isInstanceOf<BuildUnitDirectivesTask>());
+    // validate
+    List<AbstractDirective> directives = outputs[DIRECTIVES_IN_UNIT];
+    Component component = directives.single;
+    List<OutputElement> compOutputs = component.outputs;
+    expect(compOutputs, hasLength(1));
+    {
+      OutputElement output = compOutputs[0];
+      expect(output.eventType, isNotNull);
+      expect(output.eventType.toString(), equals("int"));
+    }
+  }
+
+  void test_outputs_extendStreamIsOk() {
+    String code = r'''
+import '/angular2/angular2.dart';
+import 'dart:async';
+
+abstract class MyStream<T> implements Stream<T> { }
+
+@Component(
+    selector: 'my-component',
+    template: '<p></p>')
+class MyComponent {
+  @Output()
+  MyStream<int> myOutput;
+}
+''';
+    Source source = newSource('/test.dart', code);
+    LibrarySpecificUnit target = new LibrarySpecificUnit(source, source);
+    computeResult(target, DIRECTIVES_IN_UNIT);
+    expect(task, new isInstanceOf<BuildUnitDirectivesTask>());
+    // validate
+    List<AbstractDirective> directives = outputs[DIRECTIVES_IN_UNIT];
+    Component component = directives.single;
+    List<OutputElement> compOutputs = component.outputs;
+    expect(compOutputs, hasLength(1));
+    {
+      OutputElement output = compOutputs[0];
+      expect(output.eventType, isNotNull);
+      expect(output.eventType.toString(), equals("int"));
+    }
+  }
+
+  void test_outputs_extendStreamSpecializedIsOk() {
+    String code = r'''
+import '/angular2/angular2.dart';
+import 'dart:async';
+
+class MyStream extends Stream<int> { }
+
+@Component(
+    selector: 'my-component',
+    template: '<p></p>')
+class MyComponent {
+  @Output()
+  MyStream myOutput;
+}
+''';
+    Source source = newSource('/test.dart', code);
+    LibrarySpecificUnit target = new LibrarySpecificUnit(source, source);
+    computeResult(target, DIRECTIVES_IN_UNIT);
+    expect(task, new isInstanceOf<BuildUnitDirectivesTask>());
+    // validate
+    List<AbstractDirective> directives = outputs[DIRECTIVES_IN_UNIT];
+    Component component = directives.single;
+    List<OutputElement> compOutputs = component.outputs;
+    expect(compOutputs, hasLength(1));
+    {
+      OutputElement output = compOutputs[0];
+      expect(output.eventType, isNotNull);
+      expect(output.eventType.toString(), equals("int"));
+    }
+  }
+
+  void test_outputs_extendStreamUntypedIsOk() {
+    String code = r'''
+import '/angular2/angular2.dart';
+import 'dart:async';
+
+class MyStream extends Stream { }
+
+@Component(
+    selector: 'my-component',
+    template: '<p></p>')
+class MyComponent {
+  @Output()
+  MyStream myOutput;
+}
+''';
+    Source source = newSource('/test.dart', code);
+    LibrarySpecificUnit target = new LibrarySpecificUnit(source, source);
+    computeResult(target, DIRECTIVES_IN_UNIT);
+    expect(task, new isInstanceOf<BuildUnitDirectivesTask>());
+    // validate
+    List<AbstractDirective> directives = outputs[DIRECTIVES_IN_UNIT];
+    Component component = directives.single;
+    List<OutputElement> compOutputs = component.outputs;
+    expect(compOutputs, hasLength(1));
+    {
+      OutputElement output = compOutputs[0];
+      expect(output.eventType, isNotNull);
+      expect(output.eventType.toString(), equals("dynamic"));
+    }
+  }
+
   void test_outputs_notEventEmitterTypeError() {
     String code = r'''
 import '/angular2/angular2.dart';
 
 @Component(
     selector: 'my-component',
+    template: '<p></p>')
 class MyComponent {
   @Output()
   int badOutput;
@@ -639,6 +762,34 @@ class MyComponent {
         AngularWarningCode.OUTPUT_MUST_BE_EVENTEMITTER, code, "badOutput");
   }
 
+  void test_outputs_extendStreamNotStreamHasDynamicEventType() {
+    String code = r'''
+import '/angular2/angular2.dart';
+
+@Component(
+    selector: 'my-component',
+    template: '<p></p>')
+class MyComponent {
+  @Output()
+  int badOutput;
+}
+''';
+    Source source = newSource('/test.dart', code);
+    LibrarySpecificUnit target = new LibrarySpecificUnit(source, source);
+    computeResult(target, DIRECTIVES_IN_UNIT);
+    expect(task, new isInstanceOf<BuildUnitDirectivesTask>());
+    // validate
+    List<AbstractDirective> directives = outputs[DIRECTIVES_IN_UNIT];
+    Component component = directives.single;
+    List<OutputElement> compOutputs = component.outputs;
+    expect(compOutputs, hasLength(1));
+    {
+      OutputElement output = compOutputs[0];
+      expect(output.eventType, isNotNull);
+      expect(output.eventType.toString(), equals("dynamic"));
+    }
+  }
+
   void test_noDirectives() {
     Source source = newSource(
         '/test.dart',