strong_mode.dart: remove extra asserts and throw

pkg/analyzer/lib/src/task/strong_mode.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 analyzer.src.task.strong_mode;
 
 import 'dart:collection';
 
 import 'package:analyzer/dart/element/element.dart';
 import 'package:analyzer/dart/element/type.dart';
 import 'package:analyzer/src/dart/element/element.dart';
-import 'package:analyzer/src/dart/element/type.dart';
 import 'package:analyzer/src/generated/ast.dart';
 import 'package:analyzer/src/generated/resolver.dart'
     show TypeProvider, InheritanceManager;
 import 'package:analyzer/src/generated/type_system.dart';
 import 'package:analyzer/src/generated/utilities_dart.dart';
 
 /**
- * Set the type of the sole parameter of the given [element] to the given [type].
+ * Sets the type of the field. This is stored in the field itself, and the
+ * synthetic getter/setter types.
  */
-void setParameterType(PropertyAccessorElement element, DartType type) {
-  if (element is PropertyAccessorElementImpl) {
-    ParameterElement parameter = _getParameter(element);
-    if (parameter is ParameterElementImpl) {
-      //
-      // Update the type of the parameter.
-      //
-      parameter.type = type;
-      //
-      // Update the type of the setter to reflect the new parameter type.
-      //
-      // TODO(jmesserly): why is this necessary? The function type should always
-      // delegate to the orginal element.
-      FunctionType functionType = element.type;
-      if (functionType is FunctionTypeImpl) {
-        element.type = new FunctionTypeImpl(element);
-      } else {
-        assert(false);
-      }
-    } else {
-      assert(false);
+void setFieldType(VariableElement field, DartType newType) {
+  (field as VariableElementImpl).type = newType;
+  if (field.initializer != null) {
+    (field.initializer as ExecutableElementImpl).returnType = newType;
+  }
+  if (field is PropertyInducingElementImpl) {
+    (field.getter as ExecutableElementImpl).returnType = newType;
+    if (!field.isFinal && !field.isConst) {
+      (field.setter.parameters[0] as ParameterElementImpl).type =
+          newType;
     }
-  } else {
-    throw new StateError('element is an instance of ${element.runtimeType}');
-    assert(false);
   }
 }
 
-/**
- * Set the return type of the given [element] to the given [type].
- */
-void setReturnType(ExecutableElement element, DartType type) {
-  if (element is ExecutableElementImpl) {
-    //
-    // Update the return type of the element, which is stored in two places:
-    // directly in the element and indirectly in the type of the element.
-    //
-    // TODO(jmesserly): why is this necessary? The function type should always
-    // delegate to the orginal element.
-    element.returnType = type;
-    FunctionType functionType = element.type;
-    if (functionType is FunctionTypeImpl) {
-      element.type = new FunctionTypeImpl(element);
-    } else {
-      assert(false);
-    }
-  } else {
-    assert(false);
-  }
-}
-
 /**
  * Return the element for the single parameter of the given [setter], or `null`
  * if the executable element is not a setter or does not have a single
  * parameter.
  */
 ParameterElement _getParameter(ExecutableElement setter) {
   if (setter is PropertyAccessorElement && setter.isSetter) {
     List<ParameterElement> parameters = setter.parameters;
     if (parameters.length == 1) {
       return parameters[0];
@@ skipping 227 matching lines @@
     //
     // Infer the return type.
     //
     if (element.hasImplicitReturnType) {
       overriddenMethods = inheritanceManager.lookupOverrides(
           element.enclosingElement, element.name);
       if (overriddenMethods.isEmpty ||
           !_allSameElementKind(element, overriddenMethods)) {
         return;
       }
-      setReturnType(element, _computeReturnType(overriddenMethods));
+      (element as ExecutableElementImpl).returnType =
+          _computeReturnType(overriddenMethods);
       if (element is PropertyAccessorElement) {
         _updateSyntheticVariableType(element);
       }
     }
     //
     // Infer the parameter types.
     //
     List<ParameterElement> parameters = element.parameters;
     int length = parameters.length;
     for (int i = 0; i < length; ++i) {
@@ skipping 49 matching lines @@
       //
       if (newType == null || newType.isDynamic) {
         if (fieldElement.initializer != null &&
             (fieldElement.isFinal || overriddenGetters.isEmpty)) {
           newType = fieldElement.initializer.returnType;
         }
       }
       if (newType == null || newType.isBottom) {
         newType = typeProvider.dynamicType;
       }
-      (fieldElement as FieldElementImpl).type = newType;
-      setReturnType(fieldElement.getter, newType);
-      if (!fieldElement.isFinal && !fieldElement.isConst) {
-        setParameterType(fieldElement.setter, newType);
-      }
+      setFieldType(fieldElement, newType);
     }
   }
 
   void _inferFieldFormalParameter(FieldFormalParameterElement element) {
     FieldElement field = element.field;
     if (field != null && element.hasImplicitType) {
       (element as FieldFormalParameterElementImpl).type = field.type;
     }
   }
 
@@ skipping 98 matching lines @@
         results.add(element);
       }
     }
   }
 }
 
 /**
  * A class of exception that is not used anywhere else.
  */
 class _CycleException implements Exception {}