Late night strong mode cleaning.

pkg/compiler/lib/src/typechecker.dart

 // Copyright (c) 2012, 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 dart2js.typechecker;
 
 import 'common/names.dart' show Identifiers;
 import 'common/resolution.dart' show Resolution;
 import 'common/tasks.dart' show CompilerTask;
 import 'common.dart';
 import 'compiler.dart' show Compiler;
 import 'constants/expressions.dart';
 import 'constants/values.dart';
 import 'common_elements.dart';
 import 'elements/resolution_types.dart';
 import 'elements/elements.dart'
     show
         AbstractFieldElement,
         AstElement,
         ClassElement,
         ConstructorElement,
         Element,
         Elements,
         EnumClassElement,
         EnumConstantElement,
         ExecutableElement,
         FieldElement,
+        FormalElement,
         FunctionElement,
         GetterElement,
         InitializingFormalElement,
         LibraryElement,
         MemberSignature,
-        ParameterElement,
         ResolvedAst,
         SetterElement,
         TypeDeclarationElement,
         TypedElement,
         VariableElement;
 import 'elements/entities.dart' show AsyncMarker;
 import 'elements/names.dart';
 import 'enqueue.dart' show DeferredAction;
 import 'resolution/class_members.dart' show MembersCreator, ErroneousMember;
 import 'resolution/tree_elements.dart' show TreeElements;
@@ skipping 603 matching lines @@
     ResolutionDartType type;
     ResolutionDartType returnType;
     final FunctionElement element = elements.getFunctionDefinition(node);
     assert(
         element != null, failedAt(node, 'FunctionExpression with no element'));
     if (Elements.isUnresolved(element)) return const ResolutionDynamicType();
     if (element.isGenerativeConstructor) {
       type = const ResolutionDynamicType();
       returnType = const ResolutionVoidType();
 
-      element.functionSignature.forEachParameter((ParameterElement parameter) {
+      element.functionSignature.forEachParameter((FormalElement parameter) {
         if (parameter.isInitializingFormal) {
           InitializingFormalElement fieldParameter = parameter;
           checkAssignable(parameter, parameter.type,
               fieldParameter.fieldElement.computeType(resolution));
         }
       });
       if (node.initializers != null) {
         analyzeUntyped(node.initializers, inInitializer: true);
       }
     } else {
@@ skipping 1010 matching lines @@
     // of a subtype.
   }
 
   visitRethrow(Rethrow node) {
     // Nothing to do here.
   }
 
   /** Dart Programming Language Specification: 11.10 Return */
   visitReturn(Return node) {
     if (identical(node.beginToken.stringValue, 'native')) {
-      return;
+      return null;
     }
 
     final Node expression = node.expression;
 
     // Executing a return statement return e; [...] It is a static type warning
     // if the type of e may not be assigned to the declared return type of the
     // immediately enclosing function.
     if (expression != null) {
       ResolutionDartType expressionType = analyze(expression);
       if (executableContext.isGenerativeConstructor) {
@@ skipping 356 matching lines @@
 
   visitTypedef(Typedef node) {
     // Do not typecheck [Typedef] nodes.
   }
 
   visitNode(Node node) {
     reporter.internalError(node,
         'Unexpected node ${node.getObjectDescription()} in the type checker.');
   }
 }