fixes #219, able to compile multiple entry points

lib/src/checker/checker.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 dev_compiler.src.checker.checker;
 
 import 'package:analyzer/analyzer.dart';
 import 'package:analyzer/src/generated/ast.dart';
 import 'package:analyzer/src/generated/element.dart';
 import 'package:analyzer/src/generated/scanner.dart' show Token, TokenType;
@@ skipping 315 matching lines @@
   void _recordMessage(StaticInfo info) {
     if (info == null) return;
     var error = info.toAnalysisError();
     if (error.errorCode.errorSeverity == ErrorSeverity.ERROR) _failure = true;
     _reporter.onError(error);
   }
 }
 
 /// Checks the body of functions and properties.
 class CodeChecker extends RecursiveAstVisitor {
-  final TypeRules _rules;
-  final AnalysisErrorListener _reporter;
+  final TypeRules rules;
+  final AnalysisErrorListener reporter;
   final _OverrideChecker _overrideChecker;
   bool _failure = false;
   bool get failure => _failure || _overrideChecker._failure;
 
   CodeChecker(TypeRules rules, AnalysisErrorListener reporter,
       StrongModeOptions options)
-      : _rules = rules,
-        _reporter = reporter,
+      : rules = rules,
+        reporter = reporter,
         _overrideChecker = new _OverrideChecker(rules, reporter, options);
 
   @override
   void visitCompilationUnit(CompilationUnit unit) {
     void report(Expression expr) {
-      _reporter.onError(new MissingTypeError(expr).toAnalysisError());
+      reporter.onError(new MissingTypeError(expr).toAnalysisError());
     }
-    var callback = _rules.reportMissingType;
-    _rules.reportMissingType = report;
+    var callback = rules.reportMissingType;
+    rules.reportMissingType = report;
     unit.visitChildren(this);
-    _rules.reportMissingType = callback;
+    rules.reportMissingType = callback;
   }
 
   @override
   void visitComment(Comment node) {
     // skip, no need to do typechecking inside comments (they may contain
     // comment references which would require resolution).
   }
 
   @override
   void visitClassDeclaration(ClassDeclaration node) {
     _overrideChecker.check(node);
     super.visitClassDeclaration(node);
   }
 
   @override
   void visitAssignmentExpression(AssignmentExpression node) {
     var token = node.operator;
     if (token.type != TokenType.EQ) {
       _checkCompoundAssignment(node);
     } else {
-      DartType staticType = _rules.getStaticType(node.leftHandSide);
+      DartType staticType = rules.getStaticType(node.leftHandSide);
       checkAssignment(node.rightHandSide, staticType);
     }
     node.visitChildren(this);
   }
 
   /// Check constructor declaration to ensure correct super call placement.
   @override
   void visitConstructorDeclaration(ConstructorDeclaration node) {
     node.visitChildren(this);
 
     final init = node.initializers;
     for (int i = 0, last = init.length - 1; i < last; i++) {
       final node = init[i];
       if (node is SuperConstructorInvocation) {
         _recordMessage(new InvalidSuperInvocation(node));
       }
     }
   }
 
   @override
   void visitConstructorFieldInitializer(ConstructorFieldInitializer node) {
     var field = node.fieldName;
-    DartType staticType = _rules.elementType(field.staticElement);
+    DartType staticType = rules.elementType(field.staticElement);
     checkAssignment(node.expression, staticType);
     node.visitChildren(this);
   }
 
   @override
   void visitForEachStatement(ForEachStatement node) {
     // Check that the expression is an Iterable.
     var expr = node.iterable;
-    var iterableType = _rules.provider.iterableType;
+    var iterableType = rules.provider.iterableType;
     var loopVariable = node.identifier != null
         ? node.identifier
         : node.loopVariable.identifier;
     var iteratorType = loopVariable.staticType;
     var checkedType = iterableType.substitute4([iteratorType]);
     checkAssignment(expr, checkedType);
     node.visitChildren(this);
   }
 
   @override
@@ skipping 26 matching lines @@
   void visitSwitchStatement(SwitchStatement node) {
     // SwitchStatement defines a boolean conversion to check the result of the
     // case value == the switch value, but in dev_compiler we require a boolean
     // return type from an overridden == operator (because Object.==), so
     // checking in SwitchStatement shouldn't be necessary.
     node.visitChildren(this);
   }
 
   @override
   void visitListLiteral(ListLiteral node) {
-    var type = _rules.provider.dynamicType;
+    var type = rules.provider.dynamicType;
     if (node.typeArguments != null) {
       var targs = node.typeArguments.arguments;
       if (targs.length > 0) type = targs[0].type;
     }
     var elements = node.elements;
     for (int i = 0; i < elements.length; i++) {
       checkArgument(elements[i], type);
     }
     super.visitListLiteral(node);
   }
 
   @override
   void visitMapLiteral(MapLiteral node) {
-    var ktype = _rules.provider.dynamicType;
-    var vtype = _rules.provider.dynamicType;
+    var ktype = rules.provider.dynamicType;
+    var vtype = rules.provider.dynamicType;
     if (node.typeArguments != null) {
       var targs = node.typeArguments.arguments;
       if (targs.length > 0) ktype = targs[0].type;
       if (targs.length > 1) vtype = targs[1].type;
     }
     var entries = node.entries;
     for (int i = 0; i < entries.length; i++) {
       var entry = entries[i];
       checkArgument(entry.key, ktype);
       checkArgument(entry.value, vtype);
@@ skipping 11 matching lines @@
       if (element == null) {
         if (type.parameters.length < len) {
           // We found an argument mismatch, the analyzer will report this too,
           // so no need to insert an error for this here.
           continue;
         }
         element = type.parameters[i];
         // TODO(vsm): When can this happen?
         assert(element != null);
       }
-      DartType expectedType = _rules.elementType(element);
-      if (expectedType == null) expectedType = _rules.provider.dynamicType;
+      DartType expectedType = rules.elementType(element);
+      if (expectedType == null) expectedType = rules.provider.dynamicType;
       checkArgument(arg, expectedType);
     }
   }
 
   void checkArgument(Expression arg, DartType expectedType) {
     // Preserve named argument structure, so their immediate parent is the
     // method invocation.
     if (arg is NamedExpression) {
       arg = (arg as NamedExpression).expression;
     }
     checkAssignment(arg, expectedType);
   }
 
   void checkFunctionApplication(
       Expression node, Expression f, ArgumentList list) {
-    if (_rules.isDynamicCall(f)) {
+    if (rules.isDynamicCall(f)) {
       // If f is Function and this is a method invocation, we should have
       // gotten an analyzer error, so no need to issue another error.
       _recordDynamicInvoke(node, f);
     } else {
-      checkArgumentList(list, _rules.getTypeAsCaller(f));
+      checkArgumentList(list, rules.getTypeAsCaller(f));
     }
   }
 
   @override
   visitMethodInvocation(MethodInvocation node) {
     var target = node.realTarget;
-    if (_rules.isDynamicTarget(target)) {
+    if (rules.isDynamicTarget(target)) {
       _recordDynamicInvoke(node, target);
 
       // Mark the tear-off as being dynamic, too. This lets us distinguish
       // cases like:
       //
       //     dynamic d;
       //     d.someMethod(...); // the whole method call must be a dynamic send.
       //
       // ... from case like:
       //
@@ skipping 32 matching lines @@
       var type = node.staticElement.type;
       checkArgumentList(node.argumentList, type);
     }
     node.visitChildren(this);
   }
 
   DartType _getExpectedReturnType(FunctionBody body, bool yieldStar) {
     FunctionType functionType;
     var parent = body.parent;
     if (parent is Declaration) {
-      functionType = _rules.elementType(parent.element);
+      functionType = rules.elementType(parent.element);
     } else {
       assert(parent is FunctionExpression);
-      functionType = _rules.getStaticType(parent);
+      functionType = rules.getStaticType(parent);
     }
 
     var type = functionType.returnType;
-    var provider = _rules.provider;
+    var provider = rules.provider;
 
     InterfaceType expectedType = null;
     if (body.isAsynchronous) {
       if (body.isGenerator) {
         // Stream<T> -> T
         expectedType = provider.streamType;
       } else {
         // Future<T> -> T
         // TODO(vsm): Revisit with issue #228.
         expectedType = provider.futureType;
@@ skipping 61 matching lines @@
   }
 
   @override
   void visitYieldStatement(YieldStatement node) {
     _checkReturnOrYield(node.expression, node, node.star != null);
     node.visitChildren(this);
   }
 
   @override
   void visitAwaitExpression(AwaitExpression node) {
-    checkAssignment(node.expression, _rules.provider.futureDynamicType);
+    checkAssignment(node.expression, rules.provider.futureDynamicType);
     node.visitChildren(this);
   }
 
   @override
   void visitPropertyAccess(PropertyAccess node) {
     var target = node.realTarget;
-    if (_rules.isDynamicTarget(target)) {
+    if (rules.isDynamicTarget(target)) {
       _recordDynamicInvoke(node, target);
     }
     node.visitChildren(this);
   }
 
   @override
   void visitPrefixedIdentifier(PrefixedIdentifier node) {
     final target = node.prefix;
-    if (_rules.isDynamicTarget(target)) {
+    if (rules.isDynamicTarget(target)) {
       _recordDynamicInvoke(node, target);
     }
     node.visitChildren(this);
   }
 
   @override
   void visitDefaultFormalParameter(DefaultFormalParameter node) {
     // Check that defaults have the proper subtype.
     var parameter = node.parameter;
-    var parameterType = _rules.elementType(parameter.element);
+    var parameterType = rules.elementType(parameter.element);
     assert(parameterType != null);
     var defaultValue = node.defaultValue;
     if (defaultValue == null) {
-      if (_rules.maybeNonNullableType(parameterType)) {
+      if (rules.maybeNonNullableType(parameterType)) {
         var staticInfo = new InvalidVariableDeclaration(
-            _rules, node.identifier, parameterType);
+            rules, node.identifier, parameterType);
         _recordMessage(staticInfo);
       }
     } else {
       checkAssignment(defaultValue, parameterType);
     }
 
     node.visitChildren(this);
   }
 
   @override
   void visitFieldFormalParameter(FieldFormalParameter node) {
     var element = node.element;
     var typeName = node.type;
     if (typeName != null) {
-      var type = _rules.elementType(element);
+      var type = rules.elementType(element);
       var fieldElement =
           node.identifier.staticElement as FieldFormalParameterElement;
-      var fieldType = _rules.elementType(fieldElement.field);
-      if (!_rules.isSubTypeOf(type, fieldType)) {
+      var fieldType = rules.elementType(fieldElement.field);
+      if (!rules.isSubTypeOf(type, fieldType)) {
         var staticInfo =
-            new InvalidParameterDeclaration(_rules, node, fieldType);
+            new InvalidParameterDeclaration(rules, node, fieldType);
         _recordMessage(staticInfo);
       }
     }
     node.visitChildren(this);
   }
 
   @override
   void visitInstanceCreationExpression(InstanceCreationExpression node) {
     var arguments = node.argumentList;
     var element = node.staticElement;
     if (element != null) {
-      var type = _rules.elementType(node.staticElement);
+      var type = rules.elementType(node.staticElement);
       checkArgumentList(arguments, type);
     } else {
       _recordMessage(new MissingTypeError(node));
     }
     node.visitChildren(this);
   }
 
   @override
   void visitVariableDeclarationList(VariableDeclarationList node) {
     TypeName type = node.type;
     if (type == null) {
       // No checks are needed when the type is var. Although internally the
       // typing rules may have inferred a more precise type for the variable
       // based on the initializer.
     } else {
       var dartType = getType(type);
       for (VariableDeclaration variable in node.variables) {
         var initializer = variable.initializer;
         if (initializer != null) {
           checkAssignment(initializer, dartType);
-        } else if (_rules.maybeNonNullableType(dartType)) {
+        } else if (rules.maybeNonNullableType(dartType)) {
           var element = variable.element;
           if (element is FieldElement && !element.isStatic) {
             // Initialized - possibly implicitly - during construction.
             // Handle this via a runtime check during code generation.
 
             // TODO(vsm): Detect statically whether this can fail and
             // report a static error (must fail) or warning (can fail).
           } else {
             var staticInfo =
-                new InvalidVariableDeclaration(_rules, variable, dartType);
+                new InvalidVariableDeclaration(rules, variable, dartType);
             _recordMessage(staticInfo);
           }
         }
       }
     }
     node.visitChildren(this);
   }
 
   void _checkRuntimeTypeCheck(AstNode node, TypeName typeName) {
     var type = getType(typeName);
-    if (!_rules.isGroundType(type)) {
+    if (!rules.isGroundType(type)) {
       _recordMessage(new InvalidRuntimeCheckError(node, type));
     }
   }
 
   @override
   void visitAsExpression(AsExpression node) {
     // We could do the same check as the IsExpression below, but that is
     // potentially too conservative.  Instead, at runtime, we must fail hard
     // if the Dart as and the DDC as would return different values.
     node.visitChildren(this);
@@ skipping 19 matching lines @@
   void visitPostfixExpression(PostfixExpression node) {
     _checkUnary(node);
     node.visitChildren(this);
   }
 
   void _checkUnary(/*PrefixExpression|PostfixExpression*/ node) {
     var op = node.operator;
     if (op.isUserDefinableOperator ||
         op.type == TokenType.PLUS_PLUS ||
         op.type == TokenType.MINUS_MINUS) {
-      if (_rules.isDynamicTarget(node.operand)) {
+      if (rules.isDynamicTarget(node.operand)) {
         _recordDynamicInvoke(node, node.operand);
       }
       // For ++ and --, even if it is not dynamic, we still need to check
       // that the user defined method accepts an `int` as the RHS.
       // We assume Analyzer has done this already.
     }
   }
 
   @override
   void visitBinaryExpression(BinaryExpression node) {
     var op = node.operator;
     if (op.isUserDefinableOperator) {
-      if (_rules.isDynamicTarget(node.leftOperand)) {
+      if (rules.isDynamicTarget(node.leftOperand)) {
         // Dynamic invocation
         // TODO(vsm): Move this logic to the resolver?
         if (op.type != TokenType.EQ_EQ && op.type != TokenType.BANG_EQ) {
           _recordDynamicInvoke(node, node.leftOperand);
         }
       } else {
         var element = node.staticElement;
         // Method invocation.
         if (element is MethodElement) {
           var type = element.type as FunctionType;
@@ skipping 25 matching lines @@
 
   @override
   void visitConditionalExpression(ConditionalExpression node) {
     checkBoolean(node.condition);
     node.visitChildren(this);
   }
 
   @override
   void visitIndexExpression(IndexExpression node) {
     var target = node.realTarget;
-    if (_rules.isDynamicTarget(target)) {
+    if (rules.isDynamicTarget(target)) {
       _recordDynamicInvoke(node, target);
     } else {
       var element = node.staticElement;
       if (element is MethodElement) {
         var type = element.type as FunctionType;
         // Analyzer should enforce number of parameter types, but check in
         // case we have erroneous input.
         if (type.normalParameterTypes.isNotEmpty) {
           checkArgument(node.index, type.normalParameterTypes[0]);
         }
       } else {
         // TODO(vsm): Assert that the analyzer found an error here?
       }
     }
     node.visitChildren(this);
   }
 
   DartType getType(TypeName name) {
-    return (name == null) ? _rules.provider.dynamicType : name.type;
+    return (name == null) ? rules.provider.dynamicType : name.type;
   }
 
   /// Analyzer checks boolean conversions, but we need to check too, because
   /// it uses the default assignability rules that allow `dynamic` and `Object`
   /// to be assigned to bool with no message.
   void checkBoolean(Expression expr) =>
-      checkAssignment(expr, _rules.provider.boolType);
+      checkAssignment(expr, rules.provider.boolType);
 
   void checkAssignment(Expression expr, DartType type) {
     if (expr is ParenthesizedExpression) {
       checkAssignment(expr.expression, type);
     } else {
-      _recordMessage(_rules.checkAssignment(expr, type));
+      _recordMessage(rules.checkAssignment(expr, type));
     }
   }
 
   DartType _specializedBinaryReturnType(
       TokenType op, DartType t1, DartType t2, DartType normalReturnType) {
     // This special cases binary return types as per 16.26 and 16.27 of the
     // Dart language spec.
     switch (op) {
       case TokenType.PLUS:
       case TokenType.MINUS:
       case TokenType.STAR:
       case TokenType.TILDE_SLASH:
       case TokenType.PERCENT:
       case TokenType.PLUS_EQ:
       case TokenType.MINUS_EQ:
       case TokenType.STAR_EQ:
       case TokenType.TILDE_SLASH_EQ:
       case TokenType.PERCENT_EQ:
-        if (_rules.isIntType(t1) && _rules.isIntType(t2)) return t1;
-        if (_rules.isDoubleType(t1) && _rules.isDoubleType(t2)) return t1;
+        if (rules.isIntType(t1) && rules.isIntType(t2)) return t1;
+        if (rules.isDoubleType(t1) && rules.isDoubleType(t2)) return t1;
         // This particular combo is not spelled out in the spec, but all
         // implementations and analyzer seem to follow this.
-        if (_rules.isDoubleType(t1) && _rules.isIntType(t2)) return t1;
+        if (rules.isDoubleType(t1) && rules.isIntType(t2)) return t1;
     }
     return normalReturnType;
   }
 
   void _checkCompoundAssignment(AssignmentExpression expr) {
     var op = expr.operator.type;
     assert(op.isAssignmentOperator && op != TokenType.EQ);
     var methodElement = expr.staticElement;
     if (methodElement == null) {
       // Dynamic invocation
       _recordDynamicInvoke(expr, expr.leftHandSide);
     } else {
       // Sanity check the operator
       assert(methodElement.isOperator);
       var functionType = methodElement.type;
       var paramTypes = functionType.normalParameterTypes;
       assert(paramTypes.length == 1);
       assert(functionType.namedParameterTypes.isEmpty);
       assert(functionType.optionalParameterTypes.isEmpty);
 
       // Check the lhs type
       var staticInfo;
-      var rhsType = _rules.getStaticType(expr.rightHandSide);
-      var lhsType = _rules.getStaticType(expr.leftHandSide);
+      var rhsType = rules.getStaticType(expr.rightHandSide);
+      var lhsType = rules.getStaticType(expr.leftHandSide);
       var returnType = _specializedBinaryReturnType(
           op, lhsType, rhsType, functionType.returnType);
 
-      if (!_rules.isSubTypeOf(returnType, lhsType)) {
-        final numType = _rules.provider.numType;
+      if (!rules.isSubTypeOf(returnType, lhsType)) {
+        final numType = rules.provider.numType;
         // Try to fix up the numerical case if possible.
-        if (_rules.isSubTypeOf(lhsType, numType) &&
-            _rules.isSubTypeOf(lhsType, rhsType)) {
+        if (rules.isSubTypeOf(lhsType, numType) &&
+            rules.isSubTypeOf(lhsType, rhsType)) {
           // This is also slightly different from spec, but allows us to keep
           // compound operators in the int += num and num += dynamic cases.
           staticInfo = DownCast.create(
-              _rules, expr.rightHandSide, Coercion.cast(rhsType, lhsType));
+              rules, expr.rightHandSide, Coercion.cast(rhsType, lhsType));
           rhsType = lhsType;
         } else {
           // Static type error
-          staticInfo = new StaticTypeError(_rules, expr, lhsType);
+          staticInfo = new StaticTypeError(rules, expr, lhsType);
         }
         _recordMessage(staticInfo);
       }
 
       // Check the rhs type
       if (staticInfo is! CoercionInfo) {
         var paramType = paramTypes.first;
-        staticInfo = _rules.checkAssignment(expr.rightHandSide, paramType);
+        staticInfo = rules.checkAssignment(expr.rightHandSide, paramType);
         _recordMessage(staticInfo);
       }
     }
   }
 
   void _recordDynamicInvoke(AstNode node, AstNode target) {
-    _reporter.onError(new DynamicInvoke(_rules, node).toAnalysisError());
+    reporter.onError(new DynamicInvoke(rules, node).toAnalysisError());
     // TODO(jmesserly): we may eventually want to record if the whole operation
     // (node) was dynamic, rather than the target, but this is an easier fit
     // with what we used to do.
     DynamicInvoke.set(target, true);
   }
 
   void _recordMessage(StaticInfo info) {
     if (info == null) return;
     var error = info.toAnalysisError();
     if (error.errorCode.errorSeverity == ErrorSeverity.ERROR) _failure = true;
-    _reporter.onError(error);
+    reporter.onError(error);
 
     if (info is CoercionInfo) {
       assert(CoercionInfo.get(info.node) == null);
       CoercionInfo.set(info.node, info);
     }
   }
 }