New analyzer_experimental snapshot.

pkg/analyzer_experimental/test/generated/resolver_test.dart

 // This code was auto-generated, is not intended to be edited, and is subject to
 // significant change. Please see the README file for more information.
 library engine.resolver_test;
 import 'dart:collection';
 import 'package:analyzer_experimental/src/generated/java_core.dart';
 import 'package:analyzer_experimental/src/generated/java_engine.dart';
 import 'package:analyzer_experimental/src/generated/java_junit.dart';
 import 'package:analyzer_experimental/src/generated/source_io.dart';
 import 'package:analyzer_experimental/src/generated/error.dart';
 import 'package:analyzer_experimental/src/generated/scanner.dart';
@@ skipping 2124 matching lines @@
     resolve(source);
     assertNoErrors();
     verify([source]);
   }
   void test_newWithUndefinedConstructorDefault() {
     Source source = addSource(EngineTestCase.createSource(["class A {", "  A() {}", "}", "f() {", "  new A();", "}"]));
     resolve(source);
     assertNoErrors();
     verify([source]);
   }
-  void test_nonBoolExpression_assert_bool() {
-    Source source = addSource(EngineTestCase.createSource(["f() {", "  assert(true);", "}"]));
-    resolve(source);
-    assertNoErrors();
-    verify([source]);
-  }
-  void test_nonBoolExpression_assert_functionType() {
+  void test_nonBoolExpression_functionType() {
     Source source = addSource(EngineTestCase.createSource([
         "bool makeAssertion() => true;",
         "f() {",
         "  assert(makeAssertion);",
         "}"]));
     resolve(source);
     assertNoErrors();
     verify([source]);
   }
+  void test_nonBoolExpression_interfaceType() {
+    Source source = addSource(EngineTestCase.createSource(["f() {", "  assert(true);", "}"]));
+    resolve(source);
+    assertNoErrors();
+    verify([source]);
+  }
   void test_nonConstantDefaultValue_function_named() {
     Source source = addSource(EngineTestCase.createSource(["f({x : 2 + 3}) {}"]));
     resolve(source);
     assertNoErrors();
     verify([source]);
   }
   void test_nonConstantDefaultValue_function_positional() {
     Source source = addSource(EngineTestCase.createSource(["f([x = 2 + 3]) {}"]));
     resolve(source);
     assertNoErrors();
@@ skipping 1349 matching lines @@
         runJUnitTest(__test, __test.test_newWithAbstractClass_factory);
       });
       _ut.test('test_newWithUndefinedConstructor', () {
         final __test = new NonErrorResolverTest();
         runJUnitTest(__test, __test.test_newWithUndefinedConstructor);
       });
       _ut.test('test_newWithUndefinedConstructorDefault', () {
         final __test = new NonErrorResolverTest();
         runJUnitTest(__test, __test.test_newWithUndefinedConstructorDefault);
       });
-      _ut.test('test_nonBoolExpression_assert_bool', () {
+      _ut.test('test_nonBoolExpression_functionType', () {
         final __test = new NonErrorResolverTest();
-        runJUnitTest(__test, __test.test_nonBoolExpression_assert_bool);
+        runJUnitTest(__test, __test.test_nonBoolExpression_functionType);
       });
-      _ut.test('test_nonBoolExpression_assert_functionType', () {
+      _ut.test('test_nonBoolExpression_interfaceType', () {
         final __test = new NonErrorResolverTest();
-        runJUnitTest(__test, __test.test_nonBoolExpression_assert_functionType);
+        runJUnitTest(__test, __test.test_nonBoolExpression_interfaceType);
       });
       _ut.test('test_nonConstCaseExpression', () {
         final __test = new NonErrorResolverTest();
         runJUnitTest(__test, __test.test_nonConstCaseExpression);
       });
       _ut.test('test_nonConstMapAsExpressionStatement_const', () {
         final __test = new NonErrorResolverTest();
         runJUnitTest(__test, __test.test_nonConstMapAsExpressionStatement_const);
       });
       _ut.test('test_nonConstMapAsExpressionStatement_notExpressionStatement', () {
@@ skipping 447 matching lines @@
     });
   }
 }
 class StaticTypeWarningCodeTest extends ResolverTestCase {
   void fail_inaccessibleSetter() {
     Source source = addSource(EngineTestCase.createSource([]));
     resolve(source);
     assertErrors([StaticTypeWarningCode.INACCESSIBLE_SETTER]);
     verify([source]);
   }
+  void fail_invocationOfNonFunction_staticInSuperclass() {
+    Source source = addSource(EngineTestCase.createSource([
+        "class A {",
+        "  static void a() {}",
+        "}",
+        "",
+        "class B extends A {",
+        "  void b() { a(); }",
+        "}"]));
+    resolve(source);
+    assertErrors([StaticTypeWarningCode.INVOCATION_OF_NON_FUNCTION]);
+    verify([source]);
+  }
   void test_inconsistentMethodInheritance_paramCount() {
     Source source = addSource(EngineTestCase.createSource([
         "abstract class A {",
         "  int x();",
         "}",
         "abstract class B {",
         "  int x(int y);",
         "}",
         "class C implements A, B {",
         "}"]));
@@ skipping 152 matching lines @@
     resolve(source);
     assertErrors([StaticTypeWarningCode.NON_BOOL_CONDITION]);
     verify([source]);
   }
   void test_nonBoolCondition_while() {
     Source source = addSource(EngineTestCase.createSource(["f() {", "  while (3) {}", "}"]));
     resolve(source);
     assertErrors([StaticTypeWarningCode.NON_BOOL_CONDITION]);
     verify([source]);
   }
-  void test_nonBoolExpression() {
+  void test_nonBoolExpression_functionType() {
+    Source source = addSource(EngineTestCase.createSource([
+        "int makeAssertion() => 1;",
+        "f() {",
+        "  assert(makeAssertion);",
+        "}"]));
+    resolve(source);
+    assertErrors([StaticTypeWarningCode.NON_BOOL_EXPRESSION]);
+    verify([source]);
+  }
+  void test_nonBoolExpression_interfaceType() {
     Source source = addSource(EngineTestCase.createSource(["f() {", "  assert(0);", "}"]));
     resolve(source);
     assertErrors([StaticTypeWarningCode.NON_BOOL_EXPRESSION]);
     verify([source]);
   }
   void test_nonTypeAsTypeArgument_notAType() {
     Source source = addSource(EngineTestCase.createSource(["int A;", "class B<E> {}", "f(B<A> b) {}"]));
     resolve(source);
     assertErrors([StaticTypeWarningCode.NON_TYPE_AS_TYPE_ARGUMENT]);
     verify([source]);
@@ skipping 430 matching lines @@
         runJUnitTest(__test, __test.test_nonBoolCondition_do);
       });
       _ut.test('test_nonBoolCondition_if', () {
         final __test = new StaticTypeWarningCodeTest();
         runJUnitTest(__test, __test.test_nonBoolCondition_if);
       });
       _ut.test('test_nonBoolCondition_while', () {
         final __test = new StaticTypeWarningCodeTest();
         runJUnitTest(__test, __test.test_nonBoolCondition_while);
       });
-      _ut.test('test_nonBoolExpression', () {
+      _ut.test('test_nonBoolExpression_functionType', () {
         final __test = new StaticTypeWarningCodeTest();
-        runJUnitTest(__test, __test.test_nonBoolExpression);
+        runJUnitTest(__test, __test.test_nonBoolExpression_functionType);
+      });
+      _ut.test('test_nonBoolExpression_interfaceType', () {
+        final __test = new StaticTypeWarningCodeTest();
+        runJUnitTest(__test, __test.test_nonBoolExpression_interfaceType);
       });
       _ut.test('test_nonTypeAsTypeArgument_notAType', () {
         final __test = new StaticTypeWarningCodeTest();
         runJUnitTest(__test, __test.test_nonTypeAsTypeArgument_notAType);
       });
       _ut.test('test_nonTypeAsTypeArgument_undefinedIdentifier', () {
         final __test = new StaticTypeWarningCodeTest();
         runJUnitTest(__test, __test.test_nonTypeAsTypeArgument_undefinedIdentifier);
       });
       _ut.test('test_returnOfInvalidType_expressionFunctionBody_function', () {
@@ skipping 2808 matching lines @@
     resolve(source);
     assertErrors([CompileTimeErrorCode.INITIALIZING_FORMAL_FOR_NON_EXISTANT_FIELD]);
     verify([source]);
   }
   void test_initializingFormalForNonExistantField_optional() {
     Source source = addSource(EngineTestCase.createSource(["class A {", "  A([this.x]) {}", "}"]));
     resolve(source);
     assertErrors([CompileTimeErrorCode.INITIALIZING_FORMAL_FOR_NON_EXISTANT_FIELD]);
     verify([source]);
   }
-  void test_initializingFormalForNonExistantField_static() {
+  void test_initializingFormalForNonExistantField_synthetic() {
+    Source source = addSource(EngineTestCase.createSource(["class A {", "  int get x => 1;", "  A(this.x) {}", "}"]));
+    resolve(source);
+    assertErrors([CompileTimeErrorCode.INITIALIZING_FORMAL_FOR_NON_EXISTANT_FIELD]);
+    verify([source]);
+  }
+  void test_initializingFormalForStaticField() {
     Source source = addSource(EngineTestCase.createSource(["class A {", "  static int x;", "  A([this.x]) {}", "}"]));
     resolve(source);
     assertErrors([CompileTimeErrorCode.INITIALIZING_FORMAL_FOR_STATIC_FIELD]);
     verify([source]);
   }
   void test_instanceMemberAccessFromStatic_field() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {",
         "  int f;",
         "  static foo() {",
@@ skipping 1911 matching lines @@
         runJUnitTest(__test, __test.test_initializingFormalForNonExistantField);
       });
       _ut.test('test_initializingFormalForNonExistantField_notInEnclosingClass', () {
         final __test = new CompileTimeErrorCodeTest();
         runJUnitTest(__test, __test.test_initializingFormalForNonExistantField_notInEnclosingClass);
       });
       _ut.test('test_initializingFormalForNonExistantField_optional', () {
         final __test = new CompileTimeErrorCodeTest();
         runJUnitTest(__test, __test.test_initializingFormalForNonExistantField_optional);
       });
-      _ut.test('test_initializingFormalForNonExistantField_static', () {
+      _ut.test('test_initializingFormalForNonExistantField_synthetic', () {
         final __test = new CompileTimeErrorCodeTest();
-        runJUnitTest(__test, __test.test_initializingFormalForNonExistantField_static);
+        runJUnitTest(__test, __test.test_initializingFormalForNonExistantField_synthetic);
+      });
+      _ut.test('test_initializingFormalForStaticField', () {
+        final __test = new CompileTimeErrorCodeTest();
+        runJUnitTest(__test, __test.test_initializingFormalForStaticField);
       });
       _ut.test('test_instanceMemberAccessFromStatic_field', () {
         final __test = new CompileTimeErrorCodeTest();
         runJUnitTest(__test, __test.test_instanceMemberAccessFromStatic_field);
       });
       _ut.test('test_instanceMemberAccessFromStatic_getter', () {
         final __test = new CompileTimeErrorCodeTest();
         runJUnitTest(__test, __test.test_instanceMemberAccessFromStatic_getter);
       });
       _ut.test('test_instanceMemberAccessFromStatic_method', () {
@@ skipping 636 matching lines @@
  * structure that should have a static type associated with them do have a static type.
  */
 class StaticTypeVerifier extends GeneralizingASTVisitor<Object> {
 
   /**
    * A list containing all of the AST Expression nodes that were not resolved.
    */
   List<Expression> _unresolvedExpressions = new List<Expression>();
 
   /**
+   * A list containing all of the AST Expression nodes for which a propagated type was computed but
+   * where that type was not more specific than the static type.
+   */
+  List<Expression> _invalidlyPropagatedExpressions = new List<Expression>();
+
+  /**
    * A list containing all of the AST TypeName nodes that were not resolved.
    */
   List<TypeName> _unresolvedTypes = new List<TypeName>();
 
   /**
    * Counter for the number of Expression nodes visited that are resolved.
    */
   int _resolvedExpressionCount = 0;
 
   /**
+   * Counter for the number of Expression nodes visited that have propagated type information.
+   */
+  int _propagatedExpressionCount = 0;
+
+  /**
    * Counter for the number of TypeName nodes visited that are resolved.
    */
   int _resolvedTypeCount = 0;
 
   /**
    * Assert that all of the visited nodes have a static type associated with them.
    */
   void assertResolved() {
     if (!_unresolvedExpressions.isEmpty || !_unresolvedTypes.isEmpty) {
-      int unresolvedExpressionCount = _unresolvedExpressions.length;
+      PrintStringWriter writer = new PrintStringWriter();
       int unresolvedTypeCount = _unresolvedTypes.length;
-      PrintStringWriter writer = new PrintStringWriter();
-      writer.print("Failed to associate types with nodes: ");
-      writer.print(unresolvedExpressionCount);
-      writer.print("/");
-      writer.print(_resolvedExpressionCount + unresolvedExpressionCount);
-      writer.print(" Expressions and ");
-      writer.print(unresolvedTypeCount);
-      writer.print("/");
-      writer.print(_resolvedTypeCount + unresolvedTypeCount);
-      writer.println(" TypeNames.");
       if (unresolvedTypeCount > 0) {
-        writer.println("TypeNames:");
+        writer.print("Failed to resolve ");
+        writer.print(unresolvedTypeCount);
+        writer.print(" of ");
+        writer.print(_resolvedTypeCount + unresolvedTypeCount);
+        writer.println(" type names:");
         for (TypeName identifier in _unresolvedTypes) {
           writer.print("  ");
           writer.print(identifier.toString());
           writer.print(" (");
           writer.print(getFileName(identifier));
           writer.print(" : ");
           writer.print(identifier.offset);
           writer.println(")");
         }
       }
+      int unresolvedExpressionCount = _unresolvedExpressions.length;
       if (unresolvedExpressionCount > 0) {
-        writer.println("Expressions:");
-        for (Expression identifier in _unresolvedExpressions) {
+        writer.println("Failed to resolve ");
+        writer.print(unresolvedExpressionCount);
+        writer.print(" of ");
+        writer.print(_resolvedExpressionCount + unresolvedExpressionCount);
+        writer.println(" expressions:");
+        for (Expression expression in _unresolvedExpressions) {
           writer.print("  ");
-          writer.print(identifier.toString());
+          writer.print(expression.toString());
           writer.print(" (");
-          writer.print(getFileName(identifier));
+          writer.print(getFileName(expression));
           writer.print(" : ");
-          writer.print(identifier.offset);
+          writer.print(expression.offset);
           writer.println(")");
         }
       }
+      int invalidlyPropagatedExpressionCount = _invalidlyPropagatedExpressions.length;
+      if (invalidlyPropagatedExpressionCount > 0) {
+        writer.println("Incorrectly propagated ");
+        writer.print(invalidlyPropagatedExpressionCount);
+        writer.print(" of ");
+        writer.print(_propagatedExpressionCount);
+        writer.println(" expressions:");
+        for (Expression expression in _invalidlyPropagatedExpressions) {
+          writer.print("  ");
+          writer.print(expression.toString());
+          writer.print(" [");
+          writer.print(expression.staticType.displayName);
+          writer.print(", ");
+          writer.print(expression.propagatedType.displayName);
+          writer.println("]");
+          writer.print("    ");
+          writer.print(getFileName(expression));
+          writer.print(" : ");
+          writer.print(expression.offset);
+          writer.println(")");
+        }
+      }
       JUnitTestCase.fail(writer.toString());
     }
   }
   Object visitBreakStatement(BreakStatement node) => null;
   Object visitCommentReference(CommentReference node) => null;
   Object visitContinueStatement(ContinueStatement node) => null;
   Object visitExportDirective(ExportDirective node) => null;
   Object visitExpression(Expression node) {
     node.visitChildren(this);
-    if (node.staticType == null) {
+    Type2 staticType = node.staticType;
+    if (staticType == null) {
       _unresolvedExpressions.add(node);
     } else {
       _resolvedExpressionCount++;
+      Type2 propagatedType = node.propagatedType;
+      if (propagatedType != null) {
+        _propagatedExpressionCount++;
+        if (!propagatedType.isMoreSpecificThan(staticType)) {
+          _invalidlyPropagatedExpressions.add(node);
+        }
+      }
     }
     return null;
   }
   Object visitImportDirective(ImportDirective node) => null;
   Object visitLabel(Label node) => null;
   Object visitLibraryIdentifier(LibraryIdentifier node) => null;
   Object visitPrefixedIdentifier(PrefixedIdentifier node) {
     if (node.staticType == null && identical(node.prefix.staticType, DynamicTypeImpl.instance)) {
       return null;
     }
@@ skipping 3811 matching lines @@
         printNodes(writer, _wrongTypedNodes);
       }
       JUnitTestCase.fail(writer.toString());
     }
   }
   Object visitBinaryExpression(BinaryExpression node) {
     node.visitChildren(this);
     if (!node.operator.isUserDefinableOperator) {
       return null;
     }
+    Type2 operandType = node.leftOperand.staticType;
+    if (operandType == null || operandType.isDynamic) {
+      return null;
+    }
     return checkResolved2(node, node.element, MethodElement);
   }
+  Object visitCommentReference(CommentReference node) => null;
   Object visitCompilationUnit(CompilationUnit node) {
     node.visitChildren(this);
     return checkResolved2(node, node.element, CompilationUnitElement);
   }
   Object visitExportDirective(ExportDirective node) => checkResolved2(node, node.element, ExportElement);
   Object visitFunctionDeclaration(FunctionDeclaration node) {
     node.visitChildren(this);
     if (node.element is LibraryElement) {
       _wrongTypedNodes.add(node);
     }
     return null;
   }
   Object visitFunctionExpressionInvocation(FunctionExpressionInvocation node) {
     node.visitChildren(this);
-    return checkResolved2(node, node.element, FunctionElement);
+    return null;
   }
   Object visitImportDirective(ImportDirective node) {
     checkResolved2(node, node.element, ImportElement);
     SimpleIdentifier prefix = node.prefix;
     if (prefix == null) {
       return null;
     }
     return checkResolved2(prefix, prefix.element, PrefixElement);
   }
   Object visitIndexExpression(IndexExpression node) {
     node.visitChildren(this);
+    Type2 targetType = node.realTarget.staticType;
+    if (targetType == null || targetType.isDynamic) {
+      return null;
+    }
     return checkResolved2(node, node.element, MethodElement);
   }
   Object visitLibraryDirective(LibraryDirective node) => checkResolved2(node, node.element, LibraryElement);
+  Object visitNamedExpression(NamedExpression node) => node.expression.accept(this);
   Object visitPartDirective(PartDirective node) => checkResolved2(node, node.element, CompilationUnitElement);
   Object visitPartOfDirective(PartOfDirective node) => checkResolved2(node, node.element, LibraryElement);
   Object visitPostfixExpression(PostfixExpression node) {
     node.visitChildren(this);
     if (!node.operator.isUserDefinableOperator) {
       return null;
     }
+    Type2 operandType = node.operand.staticType;
+    if (operandType == null || operandType.isDynamic) {
+      return null;
+    }
     return checkResolved2(node, node.element, MethodElement);
   }
+  Object visitPrefixedIdentifier(PrefixedIdentifier node) {
+    SimpleIdentifier prefix = node.prefix;
+    prefix.accept(this);
+    Type2 prefixType = prefix.staticType;
+    if (prefixType == null || prefixType.isDynamic) {
+      return null;
+    }
+    return checkResolved(node, node.element);
+  }
   Object visitPrefixExpression(PrefixExpression node) {
     node.visitChildren(this);
     if (!node.operator.isUserDefinableOperator) {
       return null;
     }
+    Type2 operandType = node.operand.staticType;
+    if (operandType == null || operandType.isDynamic) {
+      return null;
+    }
     return checkResolved2(node, node.element, MethodElement);
   }
+  Object visitPropertyAccess(PropertyAccess node) {
+    Expression target = node.realTarget;
+    target.accept(this);
+    Type2 targetType = target.staticType;
+    if (targetType == null || targetType.isDynamic) {
+      return null;
+    }
+    return node.propertyName.accept(this);
+  }
   Object visitSimpleIdentifier(SimpleIdentifier node) {
     if (node.name == "void") {
       return null;
     }
+    ASTNode parent = node.parent;
+    if (parent is MethodInvocation) {
+      MethodInvocation invocation = (parent as MethodInvocation);
+      if (identical(invocation.methodName, node)) {
+        Expression target = invocation.realTarget;
+        Type2 targetType = target == null ? null : target.staticType;
+        if (targetType == null || targetType.isDynamic) {
+          return null;
+        }
+      }
+    }
     return checkResolved(node, node.element);
   }
   Object checkResolved(ASTNode node, Element element) => checkResolved2(node, element, null);
   Object checkResolved2(ASTNode node, Element element, Type expectedClass) {
     if (element == null) {
-      if (node.parent is CommentReference) {
-        return null;
-      }
       if (_knownExceptions == null || !_knownExceptions.contains(node)) {
         _unresolvedNodes.add(node);
       }
     } else if (expectedClass != null) {
       if (!isInstanceOf(element, expectedClass)) {
         _wrongTypedNodes.add(node);
       }
     }
     return null;
   }
@@ skipping 1163 matching lines @@
         final __test = new NonHintCodeTest();
         runJUnitTest(__test, __test.test_deadCode_deadCatch_onCatchSubtype);
       });
     });
   }
 }
 class EnclosedScopeTest extends ResolverTestCase {
   void test_define_duplicate() {
     LibraryElement definingLibrary2 = createTestLibrary();
     GatheringErrorListener errorListener2 = new GatheringErrorListener();
-    Scope rootScope = new Scope_17(definingLibrary2, errorListener2);
+    Scope rootScope = new Scope_18(definingLibrary2, errorListener2);
     EnclosedScope scope = new EnclosedScope(rootScope);
     VariableElement element1 = ElementFactory.localVariableElement(ASTFactory.identifier3("v1"));
     VariableElement element2 = ElementFactory.localVariableElement(ASTFactory.identifier3("v1"));
     scope.define(element1);
     scope.define(element2);
     errorListener2.assertErrors3([ErrorSeverity.ERROR]);
   }
   void test_define_normal() {
     LibraryElement definingLibrary3 = createTestLibrary();
     GatheringErrorListener errorListener3 = new GatheringErrorListener();
-    Scope rootScope = new Scope_18(definingLibrary3, errorListener3);
+    Scope rootScope = new Scope_19(definingLibrary3, errorListener3);
     EnclosedScope outerScope = new EnclosedScope(rootScope);
     EnclosedScope innerScope = new EnclosedScope(outerScope);
     VariableElement element1 = ElementFactory.localVariableElement(ASTFactory.identifier3("v1"));
     VariableElement element2 = ElementFactory.localVariableElement(ASTFactory.identifier3("v2"));
     outerScope.define(element1);
     innerScope.define(element2);
     errorListener3.assertNoErrors();
   }
   static dartSuite() {
     _ut.group('EnclosedScopeTest', () {
       _ut.test('test_define_duplicate', () {
         final __test = new EnclosedScopeTest();
         runJUnitTest(__test, __test.test_define_duplicate);
       });
       _ut.test('test_define_normal', () {
         final __test = new EnclosedScopeTest();
         runJUnitTest(__test, __test.test_define_normal);
       });
     });
   }
 }
-class Scope_17 extends Scope {
+class Scope_18 extends Scope {
   LibraryElement definingLibrary2;
   GatheringErrorListener errorListener2;
-  Scope_17(this.definingLibrary2, this.errorListener2) : super();
+  Scope_18(this.definingLibrary2, this.errorListener2) : super();
   LibraryElement get definingLibrary => definingLibrary2;
   AnalysisErrorListener get errorListener => errorListener2;
   Element lookup3(Identifier identifier, String name, LibraryElement referencingLibrary) => null;
 }
-class Scope_18 extends Scope {
+class Scope_19 extends Scope {
   LibraryElement definingLibrary3;
   GatheringErrorListener errorListener3;
-  Scope_18(this.definingLibrary3, this.errorListener3) : super();
+  Scope_19(this.definingLibrary3, this.errorListener3) : super();
   LibraryElement get definingLibrary => definingLibrary3;
   AnalysisErrorListener get errorListener => errorListener3;
   Element lookup3(Identifier identifier, String name, LibraryElement referencingLibrary) => null;
 }
 class LibraryElementBuilderTest extends EngineTestCase {
 
   /**
    * The source factory used to create [Source].
    */
   SourceFactory _sourceFactory;
@@ skipping 1047 matching lines @@
 //  ErrorResolverTest.dartSuite();
 //  HintCodeTest.dartSuite();
 //  NonHintCodeTest.dartSuite();
 //  NonErrorResolverTest.dartSuite();
 //  SimpleResolverTest.dartSuite();
 //  StaticTypeWarningCodeTest.dartSuite();
 //  StaticWarningCodeTest.dartSuite();
 //  StrictModeTest.dartSuite();
 //  TypePropagationTest.dartSuite();
 }