housecleaning: remove nonnullableTypes

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;
 
-import '../../strong_mode.dart' show StrongModeOptions;
 import '../info.dart';
 import '../utils.dart' show getMemberType;
 import 'rules.dart';
 
 /// Checks for overriding declarations of fields and methods. This is used to
 /// check overrides between classes and superclasses, interfaces, and mixin
 /// applications.
 class _OverrideChecker {
   bool _failure = false;
   final TypeRules _rules;
@@ skipping 597 matching lines @@
     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);
     assert(parameterType != null);
     var defaultValue = node.defaultValue;
-    if (defaultValue == null) {
-      if (rules.maybeNonNullableType(parameterType)) {
-        var staticInfo = new InvalidVariableDeclaration(
-            rules, node.identifier, parameterType);
-        _recordMessage(staticInfo);
-      }
-    } else {
+    if (defaultValue != null) {
       checkAssignment(defaultValue, parameterType);
     }
 
     node.visitChildren(this);
   }
 
   @override
   void visitFieldFormalParameter(FieldFormalParameter node) {
     var element = node.element;
     var typeName = node.type;
@@ skipping 30 matching lines @@
     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)) {
-          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);
-            _recordMessage(staticInfo);
-          }
         }
       }
     }
     node.visitChildren(this);
   }
 
   void _checkRuntimeTypeCheck(AstNode node, TypeName typeName) {
     var type = getType(typeName);
     if (!rules.isGroundType(type)) {
       _recordMessage(new NonGroundTypeCheckInfo(node, type));
@@ skipping 140 matching lines @@
       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 (t1 == rules.provider.intType && t2 == rules.provider.intType) return t1;
-        if (t1  == rules.provider.doubleType && t2 == rules.provider.doubleType) return t1;
+        if (t1 == rules.provider.intType &&
+            t2 == rules.provider.intType) return t1;
+        if (t1 == rules.provider.doubleType &&
+            t2 == rules.provider.doubleType) return t1;
         // This particular combo is not spelled out in the spec, but all
         // implementations and analyzer seem to follow this.
-        if (t1 == rules.provider.doubleType && t2 == rules.provider.intType) return t1;
+        if (t1 == rules.provider.doubleType &&
+            t2 == rules.provider.intType) 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
@@ skipping 73 matching lines @@
     if (info is CoercionInfo) {
       // TODO(jmesserly): if we're run again on the same AST, we'll produce the
       // same annotations. This should be harmless. This might go away once
       // CodeChecker is integrated better with analyzer, as it will know that
       // checking has already been performed.
       // assert(CoercionInfo.get(info.node) == null);
       CoercionInfo.set(info.node, info);
     }
   }
 }