Proposed kernel AST changes for annotating parameter type checks.

pkg/kernel/lib/ast.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.
 
 /// -----------------------------------------------------------------------
 ///                           ERROR HANDLING
 /// -----------------------------------------------------------------------
 ///
 /// As a rule of thumb, errors that can be detected statically are handled by
 /// the frontend, typically by translating the erroneous code into a 'throw' or
@@ skipping 959 matching lines @@
 /// The implied getter and setter for the field are not represented explicitly,
 /// but can be made explicit if needed.
 class Field extends Member {
   DartType type; // Not null. Defaults to DynamicType.
   int flags = 0;
   Expression initializer; // May be null.
 
   /// The uri of the source file this field was loaded from.
   String fileUri;
 
+  /// Formal safety of the implicit setter's formal parameter (if there is one).
+  ///
+  /// See [FormalSafety] for details.
+  FormalSafety setterFormalSafety = FormalSafety.unsafe;
+
+  /// Interface safety of the implicit setter's formal parameter (if there is
+  /// one).
+  ///
+  /// See [InterfaceSafety] for details.
+  InterfaceSafety setterInterfaceSafety = InterfaceSafety.semiTyped;
+
   Field(Name name,
       {this.type: const DynamicType(),
       this.initializer,
       bool isCovariant: false,
       bool isFinal: false,
       bool isConst: false,
       bool isStatic: false,
       bool hasImplicitGetter,
       bool hasImplicitSetter,
       int transformerFlags: 0,
@@ skipping 750 matching lines @@
     }
   }
 }
 
 /// Expression of form `x.field`.
 ///
 /// This may invoke a getter, read a field, or tear off a method.
 class PropertyGet extends Expression {
   Expression receiver;
   Name name;
+  DispatchCategory dispatchCategory = DispatchCategory.dynamicDispatch;
 
   Reference interfaceTargetReference;
 
   PropertyGet(Expression receiver, Name name, [Member interfaceTarget])
       : this.byReference(receiver, name, getMemberReference(interfaceTarget));
 
   PropertyGet.byReference(
       this.receiver, this.name, this.interfaceTargetReference) {
     receiver?.parent = this;
   }
@@ skipping 88 matching lines @@
       value = value.accept(v);
       value?.parent = this;
     }
   }
 }
 
 /// Directly read a field, call a getter, or tear off a method.
 class DirectPropertyGet extends Expression {
   Expression receiver;
   Reference targetReference;
+  DispatchCategory dispatchCategory = DispatchCategory.dynamicDispatch;
 
   DirectPropertyGet(Expression receiver, Member target)
       : this.byReference(receiver, getMemberReference(target));
 
   DirectPropertyGet.byReference(this.receiver, this.targetReference) {
     receiver?.parent = this;
   }
 
   Member get target => targetReference?.asMember;
 
@@ skipping 69 matching lines @@
   accept1(ExpressionVisitor1 v, arg) => v.visitDirectPropertySet(this, arg);
 
   DartType getStaticType(TypeEnvironment types) => value.getStaticType(types);
 }
 
 /// Directly call an instance method, bypassing ordinary dispatch.
 class DirectMethodInvocation extends InvocationExpression {
   Expression receiver;
   Reference targetReference;
   Arguments arguments;
+  DispatchCategory dispatchCategory = DispatchCategory.dynamicDispatch;
 
   DirectMethodInvocation(
       Expression receiver, Procedure target, Arguments arguments)
       : this.byReference(receiver, getMemberReference(target), arguments);
 
   DirectMethodInvocation.byReference(
       this.receiver, this.targetReference, this.arguments) {
     receiver?.parent = this;
     arguments?.parent = this;
   }
@@ skipping 42 matching lines @@
         .substituteType(returnType);
   }
 }
 
 /// Expression of form `super.field`.
 ///
 /// This may invoke a getter, read a field, or tear off a method.
 class SuperPropertyGet extends Expression {
   Name name;
   Reference interfaceTargetReference;
+  DispatchCategory get dispatchCategory => DispatchCategory.viaThis;
 
   SuperPropertyGet(Name name, [Member interfaceTarget])
       : this.byReference(name, getMemberReference(interfaceTarget));
 
   SuperPropertyGet.byReference(this.name, this.interfaceTargetReference);
 
   Member get interfaceTarget => interfaceTargetReference?.asMember;
 
   void set interfaceTarget(Member member) {
     interfaceTargetReference = getMemberReference(member);
@@ skipping 197 matching lines @@
   ///
   /// May be `null` if the target is a synthetic static member without a name.
   Name get name;
 }
 
 /// Expression of form `x.foo(y)`.
 class MethodInvocation extends InvocationExpression {
   Expression receiver;
   Name name;
   Arguments arguments;
+  DispatchCategory dispatchCategory = DispatchCategory.dynamicDispatch;
 
   Reference interfaceTargetReference;
 
   MethodInvocation(Expression receiver, Name name, Arguments arguments,
       [Member interfaceTarget])
       : this.byReference(
             receiver, name, arguments, getMemberReference(interfaceTarget));
 
   MethodInvocation.byReference(
       this.receiver, this.name, this.arguments, this.interfaceTargetReference) {
@@ skipping 67 matching lines @@
     }
   }
 }
 
 /// Expression of form `super.foo(x)`.
 ///
 /// The provided arguments might not match the parameters of the target.
 class SuperMethodInvocation extends InvocationExpression {
   Name name;
   Arguments arguments;
+  DispatchCategory get dispatchCategory => DispatchCategory.viaThis;
 
   Reference interfaceTargetReference;
 
   SuperMethodInvocation(Name name, Arguments arguments,
       [Procedure interfaceTarget])
       : this.byReference(name, arguments, getMemberReference(interfaceTarget));
 
   SuperMethodInvocation.byReference(
       this.name, this.arguments, this.interfaceTargetReference) {
     arguments?.parent = this;
@@ skipping 1439 matching lines @@
   }
 
   transformChildren(Transformer v) {
     if (expression != null) {
       expression = expression.accept(v);
       expression?.parent = this;
     }
   }
 }
 
+/// Indication of when a runtime type check of a formal parameter (or type
+/// parameter) needs to be included in the code generated for a method.
+///
+/// [FormalSafety] annotations are considered to be part of a method's body;
+/// they only apply to concrete methods, and they affect any calls that resolve
+/// to the annotated method at runtime.  So for instance, in the following code,
+/// the "unsafe" annotation means that the type of `o` will have to be checked
+/// in the second call to `g` (when the runtime type of `c` is `D`), but not in
+/// the first.
+///
+///     class C {
+///       void f(Object o /*safe*/) { ... }
+///     }
+///     class D {
+///       void f(covariant int o /*unsafe*/) { ... }
+///     }
+///     void g(C c) {
+///       c.f('hi');
+///     }
+///     void main() {
+///       g(new C());
+///       g(new D());
+///     }
+enum FormalSafety {
+  /// Full safety; a runtime check is only needed for dynamic invocations.
+  ///
+  /// For a [FormalParameterDeclaration], the type system can guarantee that the
+  /// actual value that will be passed to the method at runtime will be an
+  /// instance of the formal parameter's type
+  /// ([FormalParameterDeclaration.type]), *provided that* the call site is not
+  /// annotated as [DispatchCategory.dynamicDispatch].
+  ///
+  /// For a [TypeParameter], the type system can guarantee that the actual type
+  /// that will be used to instantiate the type parameter at runtime will be a
+  /// subtype of the type parameter's bound ([TypeParameter.bound]),
+  /// *provided that* the call site is not annotated as
+  /// [DispatchCategory.dynamicDispatch].
+  ///
+  /// This annotation is used for static and top level methods since they never
+  /// require additional runtime checks due to covariance.
+  safe,
+
+  /// Partial safety; a runtime check is not needed for "typed" or "this"
+  /// invocations.
+  ///
+  /// For a [FormalParameterDeclaration], the type system can guarantee that the
+  /// actual value that will be passed to the method at runtime will be an
+  /// instance of the formal parameter's type
+  /// ([FormalParameterDeclaration.type]), *provided that* the invocation comes
+  /// through an invocation target that marks the corresponding type parameter
+  /// with [InterfaceSafety.typed], or the call site is annotated as
+  /// [DispatchCategory.viaThis].
+  ///
+  /// For a [TypeParameter], the type system can guarantee that the actual type
+  /// that will be used to instantiate the type parameter at runtime will be a
+  /// subtype of the type parameter's bound ([TypeParameter.bound]),
+  /// *provided that* the invocation comes through an invocation target that
+  /// marks the corresponding type parameter with [InterfaceSafety.typed], or
+  /// the call site is annotated as [DispatchCategory.viaThis].
+  semiSafe,
+
+  /// No safety; a runtime type check is always required.
+  ///
+  /// For a [FormalParameterDeclaration], the type system cannot guarantee that
+  /// the actual value that will be passed to the method at runtime will be an
+  /// instance of the formal parameter's type
+  /// ([FormalParameterDeclaration.type]).  Therefore, in the absence of
+  /// additional information from whole program analysis, a runtime type check
+  /// needs to be compiled into the body of the method.
+  ///
+  /// Not used for [TypeParameter]s.
+  unsafe,
+}
+
+/// Indication of when a call site can skip a runtime type check that would have
+/// otherwise been required by [FormalSafety].
+///
+/// [InterfaceSafety] annotations are considered to be part of a class's API;
+/// they apply to both concrete and abstract methods, and they affect any calls
+/// that resolve to the annotated method statically.  So for instance, in the
+/// following code, the "semi-typed" annotation means that the call site at g1
+/// (which statically resolves to C.f) needs a runtime type check, but the call
+/// site at g2 (which statically resolves to D.f) does not.
+///
+///     class C<T> {
+///       void f(T x /*semi-typed*/) { ... }
+///     }
+///     class D extends C<num> {

[Jennifer Messerly, 2017/08/29 23:02:23]

one thing that might be worth an example?

class C<S, T> {
  void f(S x /*semi-typed*/, T y /*semi-typed*/) { ... }
}
class D<T> extends C<num, T> {
  void f(num x /*typed*/, T y /*semi-typed*/) { ... }
}

what's nice is that illustrates that a class like `D` can have some typed and
some semi-typed parameters.

[Paul Berry, 2017/08/29 23:24:24]

Good idea.  Done.

+///       void f(num x /*typed*/);
+///     }
+///     void g1(C<num> c) {
+///       c.f(1.5);
+///     }
+///     void g2(D d) {
+///       d.f(1.5);
+///     }
+enum InterfaceSafety {
+  /// Full type guarantee; a runtime check is only needed if the concrete
+  /// parameter bound at runtime is "unsafe".
+  ///
+  /// This annotation is used for static and top level methods since they never
+  /// require additional runtime checks due to covariance.
+  ///
+  /// See [FormalSafety] for details.
+  typed,
+
+  /// Partial type guarantee; a runtime check is needed if the concrete
+  /// parameter bound at runtime is "unsafe" or "semiSafe".
+  ///
+  /// See [FormalSafety] for details.
+  semiTyped,
+}
+
+/// Categorization of a call site indicating its effect on type guarantees.
+enum DispatchCategory {
+  /// This call site binds to its callee through a specific interface.
+  ///
+  /// The front end guarantees that the target of the call exists, has the
+  /// correct arity, and accepts all of the supplied named parameters.  Further,
+  /// it guarantees that the number of type parameters supplied matches the
+  /// number of type parameters expected by the target of the call.
+  interface,
+
+  /// This call site binds to its callee via a call on `this`.
+  ///
+  /// Similar to [interface], however the target of the call is a method on
+  /// `this` or `super`, therefore all of the class's type parameters are known
+  /// to match exactly.
+  viaThis,
+
+  /// This call site is an invocation of a function object (formed either by a
+  /// tear off or a function literal).
+  ///
+  /// Similar to [interface], however the interface target of the call is not
+  /// known.
+  closure,
+
+  /// The call site is dynamic.
+  ///
+  /// The front end makes no guarantees that the target of the call will accept
+  /// the actual runtime types of the parameters, nor that the target of the
+  /// call even exists.  Everything must be checked at runtime.
+  dynamicDispatch,
+}
+
 /// Declaration of a local variable.
 ///
 /// This may occur as a statement, but is also used in several non-statement
 /// contexts, such as in [ForStatement], [Catch], and [FunctionNode].
 ///
 /// When this occurs as a statement, it must be a direct child of a [Block].
 //
 // DESIGN TODO: Should we remove the 'final' modifier from variables?
 class VariableDeclaration extends Statement {
   /// Offset of the equals sign in the source file it comes from.
@@ skipping 14 matching lines @@
 
   /// Offset of the declaration, set and used when writing the binary.
   int binaryOffsetNoTag = -1;
 
   /// For locals, this is the initial value.
   /// For parameters, this is the default value.
   ///
   /// Should be null in other cases.
   Expression initializer; // May be null.
 
+  /// If this is a formal parameter of a concrete method, its formal safety.
+  /// Otherwise ignored.
+  ///
+  /// See [FormalSafety] for details.
+  FormalSafety formalSafety = FormalSafety.safe;
+
+  /// If this is a formal parameter of a method, its interface safety.
+  /// Otherwise ignored.
+  ///
+  /// See [InterfaceSafety] for details.
+  InterfaceSafety interfaceSafety = InterfaceSafety.typed;
+
   VariableDeclaration(this.name,
       {this.initializer,
       this.type: const DynamicType(),
       bool isFinal: false,
       bool isConst: false,
       bool isFieldFormal: false,
       bool isCovariant: false}) {
     assert(type != null);
     initializer?.parent = this;
     this.isFinal = isFinal;
@@ skipping 599 matching lines @@
 /// different [FunctionType] objects.
 class TypeParameter extends TreeNode {
   String name; // Cosmetic name.
 
   /// The bound on the type variable.
   ///
   /// Should not be null except temporarily during IR construction.  Should
   /// be set to the root class for type parameters without an explicit bound.
   DartType bound;
 
+  /// If this is a type parameter of a concrete generic method, its formal
+  /// safety.  Otherwise ignored.
+  ///
+  /// See [FormalSafety] for details.
+  FormalSafety formalSafety = FormalSafety.safe;
+
+  /// If this is a type parameter of a generic method, its interface safety.
+  /// Otherwise ignored.
+  ///
+  /// See [InterfaceSafety] for details.
+  InterfaceSafety interfaceSafety = InterfaceSafety.typed;
+
   TypeParameter([this.name, this.bound]);
 
   accept(TreeVisitor v) => v.visitTypeParameter(this);
 
   visitChildren(Visitor v) {
     bound.accept(v);
   }
 
   transformChildren(Transformer v) {
     bound = v.visitDartType(bound);
@@ skipping 328 matching lines @@
   if (typedef_.canonicalName == null) {
     throw '$typedef_ has no canonical name';
   }
   return typedef_.canonicalName;
 }
 
 /// Annotation describing information which is not part of Dart semantics; in
 /// other words, if this information (or any information it refers to) changes,
 /// static analysis and runtime behavior of the library are unaffected.
 const informative = null;