Abstract over the type system.

pkg/analyzer/test/generated/resolver_test.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 engine.resolver_test;
 
 import 'dart:collection';
 
 import 'package:analyzer/src/context/context.dart' as newContext;
 import 'package:analyzer/src/generated/ast.dart';
@@ skipping 1969 matching lines @@
     FileBasedSource source =
         new FileBasedSource(FileUtilities2.createFile("/test.dart"));
     CompilationUnitElementImpl definingCompilationUnit =
         new CompilationUnitElementImpl("test.dart");
     definingCompilationUnit.librarySource =
         definingCompilationUnit.source = source;
     _definingLibrary = ElementFactory.library(context, "test");
     _definingLibrary.definingCompilationUnit = definingCompilationUnit;
     Library library = new Library(context, _listener, source);
     library.libraryElement = _definingLibrary;
-    _visitor = new ResolverVisitor(
-        library.libraryElement, source, _typeProvider, library.errorListener,
+    _visitor = new ResolverVisitor(library.libraryElement, source,
+        _typeProvider, context.typeSystem, library.errorListener,
         nameScope: library.libraryScope,
         inheritanceManager: library.inheritanceManager);
     try {
       return _visitor.elementResolver;
     } catch (exception) {
       throw new IllegalArgumentException(
           "Could not create resolver", exception);
     }
   }
 
@@ skipping 5885 matching lines @@
 
   /**
    * Return a type provider that can be used to test the results of resolution.
    *
    * @return a type provider
    * @throws AnalysisException if dart:core cannot be resolved
    */
   TypeProvider get typeProvider => analysisContext2.typeProvider;
 
   /**
+   * Return a type system that can be used to test the results of resolution.
+   *
+   * @return a type system
+   */
+  TypeSystem get typeSystem => analysisContext2.typeSystem;
+
+  /**
    * Add a source file to the content provider. The file path should be absolute.
    *
    * @param filePath the path of the file being added
    * @param contents the contents to be returned by the content provider for the specified file
    * @return the source object representing the added file
    */
   Source addNamedSource(String filePath, String contents) {
     Source source = cacheSource(filePath, contents);
     ChangeSet changeSet = new ChangeSet();
     changeSet.addedSource(source);
@@ skipping 3465 matching lines @@
         new FileBasedSource(FileUtilities2.createFile("/lib.dart"));
     CompilationUnitElementImpl definingCompilationUnit =
         new CompilationUnitElementImpl("lib.dart");
     definingCompilationUnit.librarySource =
         definingCompilationUnit.source = source;
     LibraryElementImpl definingLibrary =
         new LibraryElementImpl.forNode(context, null);
     definingLibrary.definingCompilationUnit = definingCompilationUnit;
     Library library = new Library(context, _listener, source);
     library.libraryElement = definingLibrary;
-    _visitor = new ResolverVisitor(
-        library.libraryElement, source, _typeProvider, library.errorListener,
+    _visitor = new ResolverVisitor(library.libraryElement, source,
+        _typeProvider, context.typeSystem, library.errorListener,
         nameScope: library.libraryScope,
         inheritanceManager: library.inheritanceManager);
     _visitor.overrideManager.enterScope();
     try {
       return _visitor.typeAnalyzer;
     } catch (exception) {
       throw new IllegalArgumentException(
           "Could not create analyzer", exception);
     }
   }
@@ skipping 557 matching lines @@
   }
 }''';
     _assertPropagatedIterationType(code, typeProvider.intType, null);
     _assertTypeOfMarkedExpression(code, typeProvider.intType, null);
   }
 
   void test_localVariableInference_bottom_disabled() {
     String code = r'''
 main() {
   var v = null;
-  return v; // marker
+  v; // marker
 }''';
     _assertPropagatedAssignedType(code, typeProvider.dynamicType, null);
     _assertTypeOfMarkedExpression(code, typeProvider.dynamicType, null);
   }
 
   void test_localVariableInference_constant() {
     String code = r'''
 main() {
   var v = 3;
-  return v; // marker
+  v; // marker
 }''';
     _assertPropagatedAssignedType(code, typeProvider.intType, null);
     _assertTypeOfMarkedExpression(code, typeProvider.intType, null);
   }
 
   void test_localVariableInference_declaredType_disabled() {
     String code = r'''
 main() {
   dynamic v = 3;
-  return v; // marker
+  v; // marker
 }''';
     _assertPropagatedAssignedType(
         code, typeProvider.dynamicType, typeProvider.intType);
     _assertTypeOfMarkedExpression(
         code, typeProvider.dynamicType, typeProvider.intType);
   }
 
   void test_localVariableInference_noInitializer_disabled() {
     String code = r'''
 main() {
   var v;
   v = 3;
-  return v; // marker
+  v; // marker
 }''';
     _assertPropagatedAssignedType(
         code, typeProvider.dynamicType, typeProvider.intType);
     _assertTypeOfMarkedExpression(
         code, typeProvider.dynamicType, typeProvider.intType);
   }
 
   void test_localVariableInference_transitive_field_inferred_lexical() {
     if (!AnalysisEngine.instance.useTaskModel) {
       return;
@@ skipping 62 matching lines @@
 ''';
     _assertPropagatedAssignedType(code, typeProvider.intType, null);
     _assertTypeOfMarkedExpression(code, typeProvider.intType, null);
   }
 
   void test_localVariableInference_transitive_list_local() {
     String code = r'''
 main() {
   var x = <int>[3];
   var v = x[0];
-  return v; // marker
+  v; // marker
 }''';
     _assertPropagatedAssignedType(code, typeProvider.intType, null);
     _assertTypeOfMarkedExpression(code, typeProvider.intType, null);
   }
 
   void test_localVariableInference_transitive_local() {
     String code = r'''
 main() {
   var x = 3;
   var v = x;
-  return v; // marker
+  v; // marker
 }''';
     _assertPropagatedAssignedType(code, typeProvider.intType, null);
     _assertTypeOfMarkedExpression(code, typeProvider.intType, null);
   }
 
   void test_localVariableInference_transitive_toplevel_inferred_lexical() {
     if (!AnalysisEngine.instance.useTaskModel) {
       return;
     }
     String code = r'''
 final x = 3;
 main() {
   var v = x;
-  return v; // marker
+  v; // marker
 }
 ''';
     _assertPropagatedAssignedType(code, typeProvider.intType, null);
     _assertTypeOfMarkedExpression(code, typeProvider.intType, null);
   }
 
   void test_localVariableInference_transitive_toplevel_inferred_reversed() {
     if (!AnalysisEngine.instance.useTaskModel) {
       return;
     }
     String code = r'''
 main() {
   var v = x;
-  return v; // marker
+  v; // marker
 }
 final x = 3;
 ''';
     _assertPropagatedAssignedType(code, typeProvider.intType, null);
     _assertTypeOfMarkedExpression(code, typeProvider.intType, null);
   }
 
   void test_localVariableInference_transitive_toplevel_lexical() {
     String code = r'''
 int x = 3;
 main() {
   var v = x;
-  return v; // marker
+  v; // marker
 }
 ''';
     _assertPropagatedAssignedType(code, typeProvider.intType, null);
     _assertTypeOfMarkedExpression(code, typeProvider.intType, null);
   }
 
   void test_localVariableInference_transitive_toplevel_reversed() {
     String code = r'''
 main() {
   var v = x;
-  return v; // marker
+  v; // marker
 }
 int x = 3;
 ''';
     _assertPropagatedAssignedType(code, typeProvider.intType, null);
     _assertTypeOfMarkedExpression(code, typeProvider.intType, null);
   }
 }
 
 @reflectiveTest
 class SubtypeManagerTest extends EngineTestCase {
@@ skipping 2399 matching lines @@
         // check propagated type
         FunctionType propagatedType = node.propagatedType as FunctionType;
         expect(propagatedType.returnType, test.typeProvider.stringType);
       } on AnalysisException catch (e, stackTrace) {
         thrownException[0] = new CaughtException(e, stackTrace);
       }
     }
     return null;
   }
 }