Store the result of type inference in summaries.

pkg/analyzer/test/src/summary/resynthesize_test.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 test.src.serialization.elements_test;
 
 import 'package:analyzer/dart/element/element.dart';
 import 'package:analyzer/dart/element/type.dart';
 import 'package:analyzer/src/dart/element/element.dart';
 import 'package:analyzer/src/dart/element/type.dart';
@@ skipping 12 matching lines @@
 
 main() {
   groupSep = ' | ';
   runReflectiveTests(ResynthTest);
 }
 
 @reflectiveTest
 class ResynthTest extends ResolverTestCase {
   Set<Source> otherLibrarySources = new Set<Source>();
 
-  @override
-  void setUp() {
-    super.setUp();
-    resetWithOptions(options);
-  }
-
   /**
    * Determine the analysis options that should be used for this test.
    */
   AnalysisOptionsImpl get options =>
       new AnalysisOptionsImpl()..enableGenericMethods = true;
 
   void addLibrary(String uri) {
     otherLibrarySources.add(analysisContext2.sourceFactory.forUri(uri));
   }
 
@@ skipping 495 matching lines @@
     }
     String uri = source.uri.toString();
     addLibrary('dart:core');
     return resynthesizeLibraryElement(uri, original);
   }
 
   LibraryElementImpl resynthesizeLibraryElement(
       String uri, LibraryElementImpl original) {
     Map<String, UnlinkedUnit> unlinkedSummaries = <String, UnlinkedUnit>{};
     LinkedLibrary getLinkedSummaryFor(LibraryElement lib) {
-      LibrarySerializationResult serialized =
-          serializeLibrary(lib, typeProvider);
+      LibrarySerializationResult serialized = serializeLibrary(
+          lib, typeProvider, analysisContext.analysisOptions.strongMode);
       for (int i = 0; i < serialized.unlinkedUnits.length; i++) {
         unlinkedSummaries[serialized.unitUris[i]] =
             new UnlinkedUnit.fromBuffer(serialized.unlinkedUnits[i].toBuffer());
       }
       return new LinkedLibrary.fromBuffer(serialized.linked.toBuffer());
     }
     Map<String, LinkedLibrary> linkedSummaries = <String, LinkedLibrary>{
       uri: getLinkedSummaryFor(original)
     };
     for (Source source in otherLibrarySources) {
       LibraryElement original = resolve2(source);
       String uri = source.uri.toString();
       linkedSummaries[uri] = getLinkedSummaryFor(original);
     }
     _TestSummaryResynthesizer resynthesizer = new _TestSummaryResynthesizer(
         null,
         analysisContext,
         analysisContext.typeProvider,
         analysisContext.sourceFactory,
         unlinkedSummaries,
-        linkedSummaries);
+        linkedSummaries,
+        options.strongMode);
     LibraryElementImpl resynthesized = resynthesizer.getLibraryElement(uri);
     // Check that no other summaries needed to be resynthesized to resynthesize
     // the library element.
     expect(resynthesizer.resynthesisCount, 1);
     return resynthesized;
   }
 
+  @override
+  void setUp() {
+    super.setUp();
+    resetWithOptions(options);
+  }
+
   test_class_abstract() {
     checkLibrary('abstract class C {}');
   }
 
   test_class_alias() {
     checkLibrary('class C = D with E, F; class D {} class E {} class F {}');
   }
 
   test_class_alias_abstract() {
     checkLibrary('abstract class C = D with E; class D {} class E {}');
@@ skipping 257 matching lines @@
 
   test_class_setter_external() {
     checkLibrary('class C { external void set x(int value); }');
   }
 
   test_class_setter_implicit_param_type() {
     checkLibrary('class C { void set x(value) {} }');
   }
 
   test_class_setter_implicit_return_type() {
-    if (analysisContext.analysisOptions.strongMode) {
-      // TODO(paulberry): fix this test in strong mode.
-      return;
-    }
     checkLibrary('class C { set x(int value) {} }');
   }
 
   test_class_setter_static() {
     checkLibrary('class C { static void set x(int value) {} }');
   }
 
   test_class_setters() {
-    if (analysisContext.analysisOptions.strongMode) {
-      // TODO(paulberry): fix this test in strong mode.
-      return;
-    }
     checkLibrary('class C { void set x(int value) {} set y(value) {} }');
   }
 
   test_class_supertype() {
     checkLibrary('class C extends D {} class D {}');
   }
 
   test_class_type_parameters() {
     checkLibrary('class C<T, U> {}');
   }
@@ skipping 130 matching lines @@
   test_field_documented() {
     checkLibrary('''
 class C {
   /**
    * Docs
    */
   var x;
 }''');
   }
 
+  test_field_formal_param_inferred_type_implicit() {
+    checkLibrary('class C extends D { var v; C(this.v); }'
+        ' abstract class D { int get v; }');
+  }
+
+  test_field_inferred_type_nonstatic_explicit_initialized() {
+    checkLibrary('class C { num v = 0; }');
+  }
+
+  test_field_inferred_type_nonstatic_implicit_initialized() {
+    checkLibrary('class C { var v = 0; }');
+  }
+
+  test_field_inferred_type_nonstatic_implicit_uninitialized() {
+    checkLibrary(
+        'class C extends D { var v; } abstract class D { int get v; }');
+  }
+
+  test_field_inferred_type_static_implicit_initialized() {
+    checkLibrary('class C { static var v = 0; }');
+  }
+
   test_field_propagatedType_const_noDep() {
-    if (analysisContext.analysisOptions.strongMode) {
-      // TODO(paulberry): fix this test in strong mode.
-      return;
-    }
     checkLibrary('''
 class C {
   static const x = 0;
 }''');
   }
 
   test_field_propagatedType_final_dep_inLib() {
-    if (analysisContext.analysisOptions.strongMode) {
-      // TODO(paulberry): fix this test in strong mode.
-      return;
-    }
     addNamedSource('/a.dart', 'final a = 1;');
     checkLibrary('''
 import "a.dart";
 class C {
   final b = a / 2;
 }''');
   }
 
   test_field_propagatedType_final_dep_inPart() {
-    if (analysisContext.analysisOptions.strongMode) {
-      // TODO(paulberry): fix this test in strong mode.
-      return;
-    }
     addNamedSource('/a.dart', 'part of lib; final a = 1;');
     checkLibrary('''
 library lib;
 part "a.dart";
 class C {
   final b = a / 2;
 }''');
   }
 
   test_field_propagatedType_final_noDep_instance() {
-    if (analysisContext.analysisOptions.strongMode) {
-      // TODO(paulberry): fix this test in strong mode.
-      return;
-    }
     checkLibrary('''
 class C {
   final x = 0;
 }''');
   }
 
   test_field_propagatedType_final_noDep_static() {
-    if (analysisContext.analysisOptions.strongMode) {
-      // TODO(paulberry): fix this test in strong mode.
-      return;
-    }
     checkLibrary('''
 class C {
   static final x = 0;
 }''');
   }
 
   test_function_documented() {
     checkLibrary('''
 // Extra comment so doc comment offset != 0
 /**
@@ skipping 91 matching lines @@
 /**
  * Docs
  */
 get x => null;''');
   }
 
   test_getter_external() {
     checkLibrary('external int get x;');
   }
 
+  test_getter_inferred_type_nonstatic_implicit_return() {
+    checkLibrary(
+        'class C extends D { get f => null; } abstract class D { int get f; }');
+  }
+
   test_getters() {
     checkLibrary('int get x => null; get y => null;');
   }
 
   test_implicitTopLevelVariable_getterFirst() {
     checkLibrary('int get x => 0; void set x(int value) {}');
   }
 
   test_implicitTopLevelVariable_setterFirst() {
     checkLibrary('void set x(int value) {} int get x => 0;');
@@ skipping 99 matching lines @@
   test_method_documented() {
     checkLibrary('''
 class C {
   /**
    * Docs
    */
   f() {}
 }''');
   }
 
+  test_method_inferred_type_nonstatic_implicit_param() {
+    checkLibrary('class C extends D { void f(value) {} }'
+        ' abstract class D { void f(int value); }');
+  }
+
+  test_method_inferred_type_nonstatic_implicit_return() {
+    checkLibrary(
+        'class C extends D { f() => null; } abstract class D { int f(); }');
+  }
+
   test_method_parameter_parameters() {
     checkLibrary('class C { f(g(x, y)) {} }');
   }
 
   test_method_parameter_parameters_in_generic_class() {
     checkLibrary('class C<A, B> { f(A g(B x)) {} }');
   }
 
   test_method_parameter_return_type() {
     checkLibrary('class C { f(int g()) {} }');
@@ skipping 58 matching lines @@
 /**
  * Docs
  */
 void set x(value) {}''');
   }
 
   test_setter_external() {
     checkLibrary('external void set x(int value);');
   }
 
+  test_setter_inferred_type_nonstatic_implicit_param() {
+    checkLibrary('class C extends D { void set f(value) {} }'
+        ' abstract class D { void set f(int value); }');
+  }
+
+  test_setter_inferred_type_static_implicit_return() {
+    checkLibrary('class C { static set f(int value) {} }');
+  }
+
+  test_setter_inferred_type_top_level_implicit_return() {
+    checkLibrary('set f(int value) {}');
+  }
+
   test_setters() {
-    if (analysisContext.analysisOptions.strongMode) {
-      // TODO(paulberry): fix this test in strong mode.
-      return;
-    }
     checkLibrary('void set x(int value) {} set y(value) {}');
   }
 
   test_type_arguments_explicit_dynamic_dynamic() {
     checkLibrary('Map<dynamic, dynamic> m;');
   }
 
   test_type_arguments_explicit_dynamic_int() {
     checkLibrary('Map<dynamic, int> m;');
   }
@@ skipping 235 matching lines @@
   test_variable_getterInPart_setterInPart() {
     addNamedSource('/a.dart', 'part of my.lib; int get x => 42;');
     addNamedSource('/b.dart', 'part of my.lib; void set x(int _) {}');
     checkLibrary('library my.lib; part "a.dart"; part "b.dart";');
   }
 
   test_variable_implicit_type() {
     checkLibrary('var x;');
   }
 
+  test_variable_inferred_type_implicit_initialized() {
+    checkLibrary('var v = 0;');
+  }
+
   test_variable_propagatedType_const_noDep() {
-    if (analysisContext.analysisOptions.strongMode) {
-      // TODO(paulberry): fix this test in strong mode.
-      return;
-    }
     checkLibrary('const i = 0;');
   }
 
   test_variable_propagatedType_final_dep_inLib() {
-    if (analysisContext.analysisOptions.strongMode) {
-      // TODO(paulberry): fix this test in strong mode.
-      return;
-    }
     addNamedSource('/a.dart', 'final a = 1;');
     checkLibrary('import "a.dart"; final b = a / 2;');
   }
 
   test_variable_propagatedType_final_dep_inPart() {
-    if (analysisContext.analysisOptions.strongMode) {
-      // TODO(paulberry): fix this test in strong mode.
-      return;
-    }
     addNamedSource('/a.dart', 'part of lib; final a = 1;');
     checkLibrary('library lib; part "a.dart"; final b = a / 2;');
   }
 
   test_variable_propagatedType_final_noDep() {
-    if (analysisContext.analysisOptions.strongMode) {
-      // TODO(paulberry): fix this test in strong mode.
-      return;
-    }
     checkLibrary('final i = 0;');
   }
 
   test_variable_propagatedType_implicit_dep() {
-    if (analysisContext.analysisOptions.strongMode) {
-      // TODO(paulberry): fix this test in strong mode.
-      return;
-    }
     // The propagated type is defined in a library that is not imported.
     addNamedSource('/a.dart', 'class C {}');
     addNamedSource('/b.dart', 'import "a.dart"; C f() => null;');
     checkLibrary('import "b.dart"; final x = f();');
   }
 
   test_variable_setterInPart_getterInPart() {
     addNamedSource('/a.dart', 'part of my.lib; void set x(int _) {}');
     addNamedSource('/b.dart', 'part of my.lib; int get x => 42;');
     checkLibrary('library my.lib; part "a.dart"; part "b.dart";');
   }
 
   test_variables() {
     checkLibrary('int i; int j;');
   }
 }
 
 class _TestSummaryResynthesizer extends SummaryResynthesizer {
   final Map<String, UnlinkedUnit> unlinkedSummaries;
   final Map<String, LinkedLibrary> linkedSummaries;
 
   _TestSummaryResynthesizer(
       SummaryResynthesizer parent,
       AnalysisContext context,
       TypeProvider typeProvider,
       SourceFactory sourceFactory,
       this.unlinkedSummaries,
-      this.linkedSummaries)
-      : super(parent, context, typeProvider, sourceFactory);
+      this.linkedSummaries,
+      bool strongMode)
+      : super(parent, context, typeProvider, sourceFactory, strongMode);
 
   @override
   LinkedLibrary getLinkedSummary(String uri) {
     LinkedLibrary serializedLibrary = linkedSummaries[uri];
     if (serializedLibrary == null) {
       fail('Unexpectedly tried to get linked summary for $uri');
     }
     return serializedLibrary;
   }
 
   @override
   UnlinkedUnit getUnlinkedSummary(String uri) {
     UnlinkedUnit serializedUnit = unlinkedSummaries[uri];
     if (serializedUnit == null) {
       fail('Unexpectedly tried to get unlinked summary for $uri');
     }
     return serializedUnit;
   }
 
   @override
   bool hasLibrarySummary(String uri) {
     return true;
   }
 }