Disallow uninitialized non-nullable variables

pkg/analyzer/lib/src/task/strong/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.
 
 // TODO(jmesserly): this was ported from package:dev_compiler, and needs to be
 // refactored to fit into analyzer.
 library analyzer.src.task.strong.checker;
 
 import 'package:analyzer/analyzer.dart';
 import 'package:analyzer/dart/ast/ast.dart';
@@ skipping 323 matching lines @@
     node.visitChildren(this);
   }
 
   @override
   void visitExpressionFunctionBody(ExpressionFunctionBody node) {
     _checkReturnOrYield(node.expression, node);
     node.visitChildren(this);
   }
 
   @override
+  void visitFieldDeclaration(FieldDeclaration node) {
+    _checkForNonNullNotInitialized(node.fields);
+    super.visitFieldDeclaration(node);
+  }
+
+  @override
   void visitFieldFormalParameter(FieldFormalParameter node) {
     var element = node.element;
     var typeName = node.type;
     if (typeName != null) {
       var type = _elementType(element);
       var fieldElement =
           node.identifier.staticElement as FieldFormalParameterElement;
       var fieldType = _elementType(fieldElement.field);
       if (!rules.isSubtypeOf(type, fieldType)) {
         _recordMessage(node, StrongModeCode.INVALID_PARAMETER_DECLARATION,
@@ skipping 241 matching lines @@
   void visitSuperConstructorInvocation(SuperConstructorInvocation node) {
     var element = node.staticElement;
     if (element != null) {
       var type = node.staticElement.type;
       checkArgumentList(node.argumentList, type);
     }
     node.visitChildren(this);
   }
 
   @override
+  Object visitTopLevelVariableDeclaration(TopLevelVariableDeclaration node) {
+    _checkForNonNullNotInitialized(node.variables);
+    return super.visitTopLevelVariableDeclaration(node);
+  }
+
+  @override
   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 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 {
       for (VariableDeclaration variable in node.variables) {
         var initializer = variable.initializer;
         if (initializer != null) {
           checkAssignment(initializer, type.type);
         }
       }
     }
     node.visitChildren(this);
   }
 
   @override
+  Object visitVariableDeclarationStatement(VariableDeclarationStatement node) {
+    _checkForNonNullNotInitialized(node.variables);
+    return super.visitVariableDeclarationStatement(node);
+  }
+
+  @override
   void visitWhileStatement(WhileStatement node) {
     checkBoolean(node.condition);
     node.visitChildren(this);
   }
 
   @override
   void visitYieldStatement(YieldStatement node) {
     _checkReturnOrYield(node.expression, node, yieldStar: node.star != null);
     node.visitChildren(this);
   }
@@ skipping 96 matching lines @@
 
   void _checkFieldAccess(AstNode node, AstNode target, SimpleIdentifier field) {
     if ((_isDynamicTarget(target) || field.staticElement == null) &&
         !_isObjectProperty(target, field)) {
       _recordDynamicInvoke(node, target);
     }
     node.visitChildren(this);
   }
 
   /**
+   *

[Jennifer Messerly, 2016/08/05 17:39:31]

missing doc comment here?

+   */
+  void _checkForNonNullNotInitialized(VariableDeclarationList list) {

[Jennifer Messerly, 2016/08/05 17:39:31]

you might be able to put this logic in visitVariableDeclaration? That way we
wouldn't need to walk over the list twice. Assuming those other nodes do in fact
visit the variable declaration nodes.

[stanm, 2016/08/05 18:06:52]

Awesome! Thanks!

+    NodeList<VariableDeclaration> variables = list.variables;
+    for (VariableDeclaration variable in variables) {
+      if (!list.isConst &&
+          !list.isFinal &&
+          variable.initializer == null &&
+          rules.isNonNullableType(list?.type?.type)) {
+        _recordMessage(
+            variable,
+            StaticTypeWarningCode.NON_NULLABLE_FIELD_NOT_INITIALIZED,
+            [variable.name, list?.type?.type]);
+      }
+    }
+  }
+
+  /**
    * Check if the closure [node] is unsafe due to dartbug.com/26947.  If so,
    * issue a warning.
    *
    * TODO(paulberry): eliminate this once dartbug.com/26947 is fixed.
    */
   void _checkForUnsafeBlockClosureInference(FunctionExpression node) {
     if (node.body is! BlockFunctionBody) {
       return;
     }
     if (node.element.returnType.isDynamic) {
@@ skipping 731 matching lines @@
     var visited = new Set<InterfaceType>();
     do {
       visited.add(current);
       current.mixins.reversed.forEach(
           (m) => _checkIndividualOverridesFromClass(node, m, seen, true));
       _checkIndividualOverridesFromClass(node, current.superclass, seen, true);
       current = current.superclass;
     } while (!current.isObject && !visited.contains(current));
   }
 }