Implement override checks for methods.

pkg/front_end/lib/src/fasta/kernel/kernel_class_builder.dart

 // Copyright (c) 2016, 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 fasta.kernel_class_builder;
 
 import 'package:kernel/ast.dart'
     show
         Class,
+        Constructor,
         DartType,
         Expression,
         ExpressionStatement,
         Field,
+        FunctionNode,
         InterfaceType,
         ListLiteral,
         Member,
         Name,
+        Procedure,
+        ProcedureKind,
         StaticGet,
         StringLiteral,
         Supertype,
-        Throw;
+        Throw,
+        VariableDeclaration;
+
+import 'package:kernel/class_hierarchy.dart' show ClassHierarchy;
 
 import '../errors.dart' show internalError;
 
 import '../messages.dart' show warning;
 
+import '../dill/dill_member_builder.dart' show DillMemberBuilder;
+
 import 'kernel_builder.dart'
     show
         Builder,
         ClassBuilder,
         ConstructorReferenceBuilder,
         KernelLibraryBuilder,
         KernelProcedureBuilder,
         KernelTypeBuilder,
         LibraryBuilder,
         MetadataBuilder,
         ProcedureBuilder,
         TypeVariableBuilder,
         computeDefaultTypeArguments;
 
-import '../dill/dill_member_builder.dart' show DillMemberBuilder;
-
 import 'redirecting_factory_body.dart' show RedirectingFactoryBody;
 
 abstract class KernelClassBuilder
     extends ClassBuilder<KernelTypeBuilder, InterfaceType> {
   KernelClassBuilder(
       List<MetadataBuilder> metadata,
       int modifiers,
       String name,
       List<TypeVariableBuilder> typeVariables,
       KernelTypeBuilder supertype,
@@ skipping 106 matching lines @@
           initializer: literal,
           fileUri: cls.fileUri)..fileOffset = cls.fileOffset;
       cls.addMember(field);
       return new DillMemberBuilder(field, this);
     });
     Field field = constructorsField.target;
     ListLiteral literal = field.initializer;
     literal.expressions
         .add(new StaticGet(constructor.target)..parent = literal);
   }
+
+  void checkOverrides(ClassHierarchy hierarchy) {
+    hierarchy.forEachOverridePair(cls, checkOverride);
+  }
+
+  void checkOverride(
+      Member declaredMember, Member interfaceMember, bool isSetter) {
+    if (declaredMember is Constructor || interfaceMember is Constructor) {
+      internalError(
+          "Constructor in override check.", fileUri, declaredMember.fileOffset);
+    }
+    if (declaredMember is Procedure && interfaceMember is Procedure) {
+      if (declaredMember.kind == ProcedureKind.Method &&
+          interfaceMember.kind == ProcedureKind.Method) {
+        checkMethodOverride(declaredMember, interfaceMember);
+        return;
+      }

[Johnni Winther, 2017/03/17 11:46:48]

TODO: check getters/setters/operators

[ahe, 2017/03/17 13:24:37]

Done.

+    }
+  }
+
+  void checkMethodOverride(
+      Procedure declaredMember, Procedure interfaceMember) {
+    assert(declaredMember.kind == ProcedureKind.Method);
+    assert(interfaceMember.kind == ProcedureKind.Method);
+    FunctionNode declaredFunction = declaredMember.function;
+    FunctionNode interfaceFunction = interfaceMember.function;
+    if (declaredFunction.typeParameters?.length !=
+        interfaceFunction.typeParameters?.length) {
+      if ("patched_sdk/lib/typed_data/typed_data.dart" !=
+          library.relativeFileUri) {
+        // TODO(ahe): https://github.com/dart-lang/sdk/issues/29100
+        addWarning(
+            declaredMember.fileOffset,
+            "Declared type variables of '$name::${declaredMember.name.name}' "
+            "doesn't match those on overridden method "
+            "'${interfaceMember.enclosingClass.name}::"
+            "${interfaceMember.name.name}'.");
+      }
+    }
+    if (declaredFunction.positionalParameters.length <
+            interfaceFunction.requiredParameterCount ||
+        declaredFunction.positionalParameters.length <
+            interfaceFunction.positionalParameters.length) {
+      addWarning(
+          declaredMember.fileOffset,
+          "The method '$name::${declaredMember.name.name}' has fewer "
+          "positional arguments than those of overridden method "
+          "'${interfaceMember.enclosingClass.name}::"
+          "${interfaceMember.name.name}'.");
+    }
+    if (interfaceFunction.requiredParameterCount <
+        declaredFunction.requiredParameterCount) {
+      addWarning(
+          declaredMember.fileOffset,
+          "The method '$name::${declaredMember.name.name}' has more "
+          "positional arguments than those of overridden method "

[Johnni Winther, 2017/03/17 11:46:47]

'positional' -> 'required'

[ahe, 2017/03/17 13:24:37]

That was intentional. I consider this case similar to the one above. Only
difference is who has more parameters.

[Johnni Winther, 2017/03/17 13:36:19]

Yes, but from the users perspective it doesn't make sense; they are allowed to
add more positional (optional) parameters but not more required.

[ahe, 2017/03/17 14:02:51]

Good point. I'll send an update.

+          "'${interfaceMember.enclosingClass.name}::"
+          "${interfaceMember.name.name}'.");
+    }
+    if (declaredFunction.namedParameters.isEmpty &&
+        interfaceFunction.namedParameters.isEmpty) {
+      return;
+    }
+    if (declaredFunction.namedParameters.length <
+        interfaceFunction.namedParameters.length) {
+      addWarning(
+          declaredMember.fileOffset,
+          "The method '$name::${declaredMember.name.name}' has fewer named "
+          "arguments than those of overridden method "
+          "'${interfaceMember.enclosingClass.name}::"
+          "${interfaceMember.name.name}'.");
+    }
+    Iterator<VariableDeclaration> declaredNamedParameters =
+        declaredFunction.namedParameters.iterator;
+    Iterator<VariableDeclaration> interfaceNamedParameters =
+        interfaceFunction.namedParameters.iterator;
+    outer:
+    while (declaredNamedParameters.moveNext() &&
+        interfaceNamedParameters.moveNext()) {
+      while (declaredNamedParameters.current.name !=
+          interfaceNamedParameters.current.name) {
+        if (!declaredNamedParameters.moveNext()) {
+          addWarning(
+              declaredMember.fileOffset,
+              "The method '$name::${declaredMember.name.name}' doesn't have "
+              "the named parameter '${interfaceNamedParameters.current.name}' "
+              "of override method '${interfaceMember.enclosingClass.name}::"

[Johnni Winther, 2017/03/17 11:46:47]

override -> overridden

[ahe, 2017/03/17 13:24:37]

Done.

+              "${interfaceMember.name.name}'.");
+          break outer;
+        }
+      }
+    }
+  }
+
+  void addCompileTimeError(int charOffset, String message) {
+    library.addCompileTimeError(charOffset, message, fileUri: fileUri);
+  }
+
+  void addWarning(int charOffset, String message) {
+    library.addWarning(charOffset, message, fileUri: fileUri);
+  }
+
+  void addNit(int charOffset, String message) {
+    library.addNit(charOffset, message, fileUri: fileUri);
+  }
 }