Store the result of type inference in summaries.

pkg/analyzer/test/src/summary/summary_common.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 analyzer.test.src.summary.summary_common;
 
 import 'package:analyzer/analyzer.dart';
 import 'package:analyzer/dart/ast/ast.dart';
 import 'package:analyzer/dart/element/element.dart';
 import 'package:analyzer/src/generated/engine.dart';
@@ skipping 26 matching lines @@
     AnalysisContext analysisContext = AnalysisContextFactory.contextWithCore();
     Map<String, UnlinkedPublicNamespace> uriToNamespace =
         <String, UnlinkedPublicNamespace>{};
     List<LibraryElement> libraries = [
       analysisContext.typeProvider.objectType.element.library,
       analysisContext.typeProvider.futureType.element.library
     ];
     for (LibraryElement library in libraries) {
       summarize_elements.LibrarySerializationResult serializedLibrary =
           summarize_elements.serializeLibrary(
-              library, analysisContext.typeProvider);
+              library, analysisContext.typeProvider, false);
       for (int i = 0; i < serializedLibrary.unlinkedUnits.length; i++) {
         uriToNamespace[serializedLibrary.unitUris[i]] =
             new UnlinkedUnit.fromBuffer(
                 serializedLibrary.unlinkedUnits[i].toBuffer()).publicNamespace;
       }
     }
     return uriToNamespace;
   } catch (_) {
     return null;
   }
@@ skipping 94 matching lines @@
    */
   LinkedLibrary get linked;
 
   /**
    * `true` if the linked portion of the summary only contains prelinked data.
    * This happens because we don't yet have a full linker; only a prelinker.
    */
   bool get skipFullyLinkedData;
 
   /**
+   * `true` if the linked portion of the summary contains the result of strong
+   * mode analysis.
+   */
+  bool get strongMode;
+
+  /**
    * Get access to the unlinked compilation unit summaries that result from
    * serializing and deserializing the library under test.
    */
   List<UnlinkedUnit> get unlinkedUnits;
 
   /**
    * Convert [path] to a suitably formatted absolute path URI for the current
    * platform.
    */
   String absUri(String path) {
@@ skipping 113 matching lines @@
         }
         return i;
       }
       found.add(dep.uri);
     }
     fail('Did not find dependency $relativeUri.  Found: $found');
     return null;
   }
 
   /**
+   * Test an inferred type.  If strong mode is disabled, verify that the given
+   * [slotId] exists and has no associated type.  Otherwise, behave as in
+   * [checkLinkedTypeSlot].
+   */
+  void checkInferredTypeSlot(
+      int slotId, String absoluteUri, String relativeUri, String expectedName,
+      {bool allowTypeParameters: false,
+      ReferenceKind expectedKind: ReferenceKind.classOrEnum,
+      int expectedTargetUnit: 0,
+      LinkedUnit linkedSourceUnit,
+      UnlinkedUnit unlinkedSourceUnit,
+      int numTypeParameters: 0}) {
+    if (strongMode) {
+      checkLinkedTypeSlot(slotId, absoluteUri, relativeUri, expectedName,
+          allowTypeParameters: allowTypeParameters,
+          expectedKind: expectedKind,
+          expectedTargetUnit: expectedTargetUnit,
+          linkedSourceUnit: linkedSourceUnit,
+          unlinkedSourceUnit: unlinkedSourceUnit,
+          numTypeParameters: numTypeParameters);
+    } else {
+      // A slot id should have been assigned but it should not be associated
+      // with any type.
+      expect(slotId, isNot(0));
+      expect(getTypeRefForSlot(slotId, linkedSourceUnit: linkedSourceUnit),
+          isNull);
+    }
+  }
+
+  /**
    * Verify that the dependency table *does not* contain any entries for a file
    * reachable via the given [absoluteUri] and [relativeUri].
    */
   void checkLacksDependency(String absoluteUri, String relativeUri) {
     if (expectAbsoluteUrisInDependencies) {
       // The element model doesn't (yet) store enough information to recover
       // relative URIs, so we have to use the absolute URI.
       // TODO(paulberry): fix this.
       relativeUri = absoluteUri;
     }
@@ skipping 1872 matching lines @@
         executables: serializeClassText('class C { C(); }').executables);
     expect(executable.isConst, isFalse);
   }
 
   test_constructor_non_factory() {
     UnlinkedExecutable executable = findExecutable('',
         executables: serializeClassText('class C { C(); }').executables);
     expect(executable.isFactory, isFalse);
   }
 
+  test_constructor_param_inferred_type_explicit() {
+    UnlinkedExecutable ctor =
+        serializeClassText('class C { C(int v); }').executables[0];
+    expect(ctor.kind, UnlinkedExecutableKind.constructor);
+    expect(ctor.parameters[0].inferredTypeSlot, 0);
+  }
+
+  test_constructor_param_inferred_type_implicit() {
+    UnlinkedExecutable ctor =
+        serializeClassText('class C { C(v); }').executables[0];
+    expect(ctor.kind, UnlinkedExecutableKind.constructor);
+    expect(ctor.parameters[0].inferredTypeSlot, 0);
+  }
+
   test_constructor_return_type() {
     UnlinkedExecutable executable = findExecutable('',
         executables: serializeClassText('class C { C(); }').executables);
     expect(executable.returnType, isNull);
   }
 
   test_constructor_return_type_parameterized() {
     UnlinkedExecutable executable = findExecutable('',
         executables: serializeClassText('class C<T, U> { C(); }').executables);
     expect(executable.returnType, isNull);
@@ skipping 913 matching lines @@
     expect(variable.documentationComment, isNotNull);
     checkDocumentationComment(variable.documentationComment, text);
   }
 
   test_field_final() {
     UnlinkedVariable variable =
         serializeClassText('class C { final int i = 0; }').fields[0];
     expect(variable.isFinal, isTrue);
   }
 
+  test_field_formal_param_inferred_type_explicit() {
+    UnlinkedClass cls = serializeClassText(
+        'class C extends D { var v; C(int this.v); }'
+        ' abstract class D { num get v; }',
+        className: 'C');
+    checkInferredTypeSlot(
+        cls.fields[0].inferredTypeSlot, 'dart:core', 'dart:core', 'num');
+    expect(cls.executables[0].kind, UnlinkedExecutableKind.constructor);
+    expect(cls.executables[0].parameters[0].inferredTypeSlot, 0);
+  }
+
+  test_field_formal_param_inferred_type_implicit() {
+    // Both the field `v` and the constructor argument `this.v` will have their
+    // type inferred by strong mode.  But only the field should have its
+    // inferred type stored in the summary, since the standard rules for field
+    // formal parameters will take care of the rest (they implicitly inherit
+    // the type of the associated field).
+    UnlinkedClass cls = serializeClassText(
+        'class C extends D { var v; C(this.v); }'
+        ' abstract class D { int get v; }',
+        className: 'C');
+    checkInferredTypeSlot(
+        cls.fields[0].inferredTypeSlot, 'dart:core', 'dart:core', 'int');
+    expect(cls.executables[0].kind, UnlinkedExecutableKind.constructor);
+    expect(cls.executables[0].parameters[0].inferredTypeSlot, 0);
+  }
+
+  test_field_inferred_type_nonstatic_explicit_initialized() {
+    UnlinkedVariable v = serializeClassText('class C { num v = 0; }').fields[0];
+    expect(v.inferredTypeSlot, 0);
+  }
+
+  test_field_inferred_type_nonstatic_explicit_uninitialized() {
+    UnlinkedVariable v = serializeClassText(
+        'class C extends D { num v; } abstract class D { int get v; }',
+        className: 'C',
+        allowErrors: true).fields[0];
+    expect(v.inferredTypeSlot, 0);
+  }
+
+  test_field_inferred_type_nonstatic_implicit_initialized() {
+    UnlinkedVariable v = serializeClassText('class C { var v = 0; }').fields[0];
+    checkInferredTypeSlot(v.inferredTypeSlot, 'dart:core', 'dart:core', 'int');
+  }
+
+  test_field_inferred_type_nonstatic_implicit_uninitialized() {
+    UnlinkedVariable v = serializeClassText(
+        'class C extends D { var v; } abstract class D { int get v; }',
+        className: 'C').fields[0];
+    checkInferredTypeSlot(v.inferredTypeSlot, 'dart:core', 'dart:core', 'int');
+  }
+
+  test_field_inferred_type_static_explicit_initialized() {
+    UnlinkedVariable v =
+        serializeClassText('class C { static int v = 0; }').fields[0];
+    expect(v.inferredTypeSlot, 0);
+  }
+
+  test_field_inferred_type_static_implicit_initialized() {
+    UnlinkedVariable v =
+        serializeClassText('class C { static var v = 0; }').fields[0];
+    checkInferredTypeSlot(v.inferredTypeSlot, 'dart:core', 'dart:core', 'int');
+  }
+
+  test_field_inferred_type_static_implicit_uninitialized() {
+    UnlinkedVariable v =
+        serializeClassText('class C { static var v; }').fields[0];
+    expect(v.inferredTypeSlot, 0);
+  }
+
   test_field_propagated_type_final_immediate() {
     UnlinkedVariable v =
         serializeClassText('class C { final v = 0; }').fields[0];
     checkLinkedTypeSlot(v.propagatedTypeSlot, 'dart:core', 'dart:core', 'int');
   }
 
   test_field_static() {
     UnlinkedVariable variable =
         serializeClassText('class C { static int i; }').fields[0];
     expect(variable.isStatic, isTrue);
@@ skipping 22 matching lines @@
 // Extra comment so doc comment offset != 0
 /**
  * Docs
  */
 f() {}''';
     UnlinkedExecutable executable = serializeExecutableText(text);
     expect(executable.documentationComment, isNotNull);
     checkDocumentationComment(executable.documentationComment, text);
   }
 
+  test_function_inferred_type_implicit_param() {
+    UnlinkedExecutable f = serializeExecutableText('void f(value) {}');
+    expect(f.parameters[0].inferredTypeSlot, 0);
+  }
+
+  test_function_inferred_type_implicit_return() {
+    UnlinkedExecutable f = serializeExecutableText('f() => null;');
+    expect(f.inferredReturnTypeSlot, 0);
+  }
+
   test_generic_method_in_generic_class() {
     UnlinkedClass cls = serializeClassText(
         'class C<T, U> { void m<V, W>(T t, U u, V v, W w) {} }');
     List<UnlinkedParam> params = cls.executables[0].parameters;
     checkParamTypeRef(params[0].type, 4);
     checkParamTypeRef(params[1].type, 3);
     checkParamTypeRef(params[2].type, 2);
     checkParamTypeRef(params[3].type, 1);
   }
 
   test_getter_documented() {
     String text = '''
 // Extra comment so doc comment offset != 0
 /**
  * Docs
  */
 get f => null;''';
     UnlinkedExecutable executable = serializeExecutableText(text);
     expect(executable.documentationComment, isNotNull);
     checkDocumentationComment(executable.documentationComment, text);
   }
 
+  test_getter_inferred_type_nonstatic_explicit_return() {
+    UnlinkedExecutable f = serializeClassText(
+        'class C extends D { num get f => null; }'
+        ' abstract class D { int get f; }',
+        className: 'C',
+        allowErrors: true).executables[0];
+    expect(f.inferredReturnTypeSlot, 0);
+  }
+
+  test_getter_inferred_type_nonstatic_implicit_return() {
+    UnlinkedExecutable f = serializeClassText(
+        'class C extends D { get f => null; } abstract class D { int get f; }',
+        className: 'C').executables[0];
+    checkInferredTypeSlot(
+        f.inferredReturnTypeSlot, 'dart:core', 'dart:core', 'int');
+  }
+
+  test_getter_inferred_type_static_implicit_return() {
+    UnlinkedExecutable f = serializeClassText(
+        'class C extends D { static get f => null; }'
+        ' class D { static int get f => null; }',
+        className: 'C').executables[0];
+    expect(f.inferredReturnTypeSlot, 0);
+  }
+
   test_implicit_dependencies_follow_other_dependencies() {
     if (skipFullyLinkedData) {
       return;
     }
     addNamedSource('/a.dart', 'import "b.dart"; class C {} D f() => null;');
     addNamedSource('/b.dart', 'class D {}');
     serializeLibraryText('import "a.dart"; final x = f(); C y;');
     // The dependency on b.dart is implicit, so it should be placed at the end
     // of the dependency list, after a.dart, even though the code that refers
     // to b.dart comes before the code that refers to a.dart.
@@ skipping 363 matching lines @@
   /**
    * Docs
    */
   f() {}
 }''';
     UnlinkedExecutable executable = serializeClassText(text).executables[0];
     expect(executable.documentationComment, isNotNull);
     checkDocumentationComment(executable.documentationComment, text);
   }
 
+  test_method_inferred_type_nonstatic_explicit_param() {
+    UnlinkedExecutable f = serializeClassText(
+        'class C extends D { void f(num value) {} }'
+        ' abstract class D { void f(int value); }',
+        className: 'C').executables[0];
+    expect(f.parameters[0].inferredTypeSlot, 0);
+  }
+
+  test_method_inferred_type_nonstatic_explicit_return() {
+    UnlinkedExecutable f = serializeClassText(
+        'class C extends D { num f() => null; } abstract class D { int f(); }',
+        className: 'C',
+        allowErrors: true).executables[0];
+    expect(f.inferredReturnTypeSlot, 0);
+  }
+
+  test_method_inferred_type_nonstatic_implicit_param() {
+    UnlinkedExecutable f = serializeClassText(
+        'class C extends D { void f(value) {} }'
+        ' abstract class D { void f(int value); }',
+        className: 'C').executables[0];
+    checkInferredTypeSlot(
+        f.parameters[0].inferredTypeSlot, 'dart:core', 'dart:core', 'int');
+  }
+
+  test_method_inferred_type_nonstatic_implicit_return() {
+    UnlinkedExecutable f = serializeClassText(
+        'class C extends D { f() => null; } abstract class D { int f(); }',
+        className: 'C').executables[0];
+    checkInferredTypeSlot(
+        f.inferredReturnTypeSlot, 'dart:core', 'dart:core', 'int');
+  }
+
+  test_method_inferred_type_static_implicit_param() {
+    UnlinkedExecutable f = serializeClassText(
+        'class C extends D { static void f(value) {} }'
+        ' class D { static void f(int value) {} }',
+        className: 'C').executables[0];
+    expect(f.parameters[0].inferredTypeSlot, 0);
+  }
+
+  test_method_inferred_type_static_implicit_return() {
+    UnlinkedExecutable f = serializeClassText(
+        'class C extends D { static f() => null; }'
+        ' class D { static int f() => null; }',
+        className: 'C').executables[0];
+    expect(f.inferredReturnTypeSlot, 0);
+  }
+
   test_part_declaration() {
     addNamedSource('/a.dart', 'part of my.lib;');
     String text = 'library my.lib; part "a.dart"; // <-part';
     serializeLibraryText(text);
     expect(unlinkedUnits[0].publicNamespace.parts, hasLength(1));
     expect(unlinkedUnits[0].publicNamespace.parts[0], 'a.dart');
     expect(unlinkedUnits[0].parts, hasLength(1));
     expect(unlinkedUnits[0].parts[0].uriOffset, text.indexOf('"a.dart"'));
     expect(unlinkedUnits[0].parts[0].uriEnd, text.indexOf('; // <-part'));
   }
@@ skipping 27 matching lines @@
 // Extra comment so doc comment offset != 0
 /**
  * Docs
  */
 void set f(value) {}''';
     UnlinkedExecutable executable = serializeExecutableText(text, 'f=');
     expect(executable.documentationComment, isNotNull);
     checkDocumentationComment(executable.documentationComment, text);
   }
 
+  test_setter_inferred_type_nonstatic_explicit_param() {
+    UnlinkedExecutable f = serializeClassText(
+        'class C extends D { void set f(num value) {} }'
+        ' abstract class D { void set f(int value); }',
+        className: 'C').executables[0];
+    expect(f.parameters[0].inferredTypeSlot, 0);
+  }
+
+  test_setter_inferred_type_nonstatic_explicit_return() {
+    UnlinkedExecutable f =
+        serializeClassText('class C { void set f(int value) {} }').executables[
+            0];
+    expect(f.inferredReturnTypeSlot, 0);
+  }
+
+  test_setter_inferred_type_nonstatic_implicit_param() {
+    UnlinkedExecutable f = serializeClassText(
+        'class C extends D { void set f(value) {} }'
+        ' abstract class D { void set f(int value); }',
+        className: 'C').executables[0];
+    checkInferredTypeSlot(
+        f.parameters[0].inferredTypeSlot, 'dart:core', 'dart:core', 'int');
+  }
+
+  test_setter_inferred_type_nonstatic_implicit_return() {
+    UnlinkedExecutable f =
+        serializeClassText('class C { set f(int value) {} }').executables[0];
+    checkInferredTypeSlot(f.inferredReturnTypeSlot, null, null, 'void');
+  }
+
+  test_setter_inferred_type_static_implicit_param() {
+    UnlinkedExecutable f = serializeClassText(
+        'class C extends D { static void set f(value) {} }'
+        ' class D { static void set f(int value) {} }',
+        className: 'C').executables[0];
+    expect(f.parameters[0].inferredTypeSlot, 0);
+  }
+
+  test_setter_inferred_type_static_implicit_return() {
+    UnlinkedExecutable f =
+        serializeClassText('class C { static set f(int value) {} }')
+            .executables[0];
+    expect(f.inferredReturnTypeSlot, 0);
+  }
+
+  test_setter_inferred_type_top_level_implicit_param() {
+    UnlinkedExecutable f =
+        serializeExecutableText('void set f(value) {}', 'f=');
+    expect(f.parameters[0].inferredTypeSlot, 0);
+  }
+
+  test_setter_inferred_type_top_level_implicit_return() {
+    UnlinkedExecutable f = serializeExecutableText('set f(int value) {}', 'f=');
+    expect(f.inferredReturnTypeSlot, 0);
+  }
+
   test_slot_reuse() {
     // Different compilation units have independent notions of slot id, so slot
     // ids should be reused.
     addNamedSource('/a.dart', 'part of foo; final v = 0;');
     serializeLibraryText('library foo; part "a.dart"; final w = 0;');
     expect(unlinkedUnits[0].variables[0].propagatedTypeSlot, 1);
     expect(unlinkedUnits[1].variables[0].propagatedTypeSlot, 1);
   }
 
   test_type_arguments_explicit() {
@@ skipping 499 matching lines @@
     UnlinkedVariable variable =
         serializeVariableText('final int i = 0;', variableName: 'i');
     expect(variable.isFinal, isTrue);
   }
 
   test_variable_implicit_dynamic() {
     UnlinkedVariable variable = serializeVariableText('var v;');
     expect(variable.type, isNull);
   }
 
+  test_variable_inferred_type_explicit_initialized() {
+    UnlinkedVariable v = serializeVariableText('int v = 0;');
+    expect(v.inferredTypeSlot, 0);
+  }
+
+  test_variable_inferred_type_implicit_initialized() {
+    UnlinkedVariable v = serializeVariableText('var v = 0;');
+    checkInferredTypeSlot(v.inferredTypeSlot, 'dart:core', 'dart:core', 'int');
+  }
+
+  test_variable_inferred_type_implicit_uninitialized() {
+    UnlinkedVariable v = serializeVariableText('var v;');
+    expect(v.inferredTypeSlot, 0);
+  }
+
   test_variable_name() {
     UnlinkedVariable variable =
         serializeVariableText('int i;', variableName: 'i');
     expect(variable.name, 'i');
   }
 
   test_variable_no_flags() {
     UnlinkedVariable variable =
         serializeVariableText('int i;', variableName: 'i');
     expect(variable.isStatic, isFalse);
@@ skipping 107 matching lines @@
     expect(constExpr.operations, operators);
     expect(constExpr.ints, ints);
     expect(constExpr.doubles, doubles);
     expect(constExpr.strings, strings);
     expect(constExpr.references, hasLength(referenceValidators.length));
     for (int i = 0; i < referenceValidators.length; i++) {
       referenceValidators[i](constExpr.references[i]);
     }
   }
 }