mirror of
https://github.com/dart-lang/sdk
synced 2024-09-16 04:27:17 +00:00
407428311f
Change-Id: I277a4f29d39c2c4d2669931b5f4837db65589167 Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/149522 Auto-Submit: Kevin Moore <kevmoo@google.com> Commit-Queue: Leaf Petersen <leafp@google.com> Reviewed-by: Leaf Petersen <leafp@google.com>
157 lines
3.8 KiB
Dart
157 lines
3.8 KiB
Dart
// Copyright (c) 2019, 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.
|
|
|
|
// Tests extension methods on the non-function, non-class types.
|
|
|
|
import "dart:async" show FutureOr;
|
|
|
|
import "package:expect/expect.dart";
|
|
|
|
void main() {
|
|
M m = C();
|
|
Object o = Object();
|
|
Function fun = () => null;
|
|
f() => 0;
|
|
String f1(int x) => "$x";
|
|
String f2([int x = 0, int y = 0]) => "${x + y}";
|
|
int i = 0;
|
|
Future<int> fi = Future<int>.value(0);
|
|
Future<Future<int>> ffi = Future<Future<int>>.value(fi);
|
|
FutureOr<FutureOr<int>> foi = 1;
|
|
Future<Null> fn = Future<Null>.value(null);
|
|
Null n = null;
|
|
|
|
// `on M` matches mixin interface.
|
|
Expect.equals(1, m.m);
|
|
// `on void` matches anything.
|
|
Expect.equals(2, o.v);
|
|
Expect.equals(2, n.v);
|
|
// `on dynamic` matches anything.
|
|
Expect.equals(3, o.d);
|
|
Expect.equals(3, n.d);
|
|
// `on Function` matches any function type and Function itself.
|
|
Expect.equals(4, f.f);
|
|
Expect.equals(4, fun.f);
|
|
Expect.equals(4, f1.f);
|
|
Expect.equals(4, f2.f);
|
|
// `on <function type>` matches those functions.
|
|
Expect.equals(5, f1.fu);
|
|
Expect.equals(5, f2.fu);
|
|
// `on FutureOr<int>` matches both future and not.
|
|
Expect.equals(6, i.fi);
|
|
Expect.equals(6, fi.fi);
|
|
// `on FutureOr<Object>` matches everything.
|
|
Expect.equals(7, o.fo);
|
|
Expect.equals(7, n.fo);
|
|
// `on FutureOr<Future<Object>>` matches any future or futureOr.
|
|
Expect.equals(8, fi.ffo);
|
|
Expect.equals(8, ffi.ffo);
|
|
// `on FutureOr<Null>` matches Null and FutureOr<Null>.
|
|
Expect.equals(9, fn.fn);
|
|
Expect.equals(9, n.fn);
|
|
// `on Null` does match null. No errors for receiver being null.
|
|
Expect.equals(10, n.n);
|
|
|
|
// Matching can deconstruct static function types.
|
|
Expect.equals(int, f1.parameterType);
|
|
Expect.equals(String, f1.returnType);
|
|
Expect.equals(int, f2.parameterType);
|
|
Expect.equals(String, f2.returnType);
|
|
// And static FutureOr types.
|
|
Expect.equals(int, i.futureType);
|
|
Expect.equals(int, fi.futureType);
|
|
Expect.equals(type<Future<int>>(), ffi.futureType);
|
|
Expect.equals(type<FutureOr<int>>(), foi.futureType);
|
|
// TODO: Update and enable when
|
|
// https://github.com/dart-lang/language/issues/436
|
|
// is resolved.
|
|
// Expect.equals(dynamic, n.futureType); // Inference treats `null` as no hint.
|
|
}
|
|
|
|
Type type<T>() => T;
|
|
|
|
mixin M {}
|
|
|
|
class C = Object with M;
|
|
|
|
extension on M {
|
|
int get m => 1;
|
|
}
|
|
|
|
extension on void {
|
|
int get v => 2;
|
|
testVoid() {
|
|
// No access on void. Static type of `this` is void!
|
|
this //
|
|
.toString() //# 01: compile-time error
|
|
;
|
|
}
|
|
}
|
|
|
|
extension on dynamic {
|
|
int get d => 3;
|
|
|
|
void testDynamic() {
|
|
// Static type of `this` is dynamic, allows dynamic invocation.
|
|
this.arglebargle();
|
|
}
|
|
}
|
|
|
|
extension on Function {
|
|
int get f => 4;
|
|
|
|
void testFunction() {
|
|
// Static type of `this` is Function. Allows any dynamic invocation.
|
|
this();
|
|
this(1);
|
|
this(x: 1);
|
|
// No function can have both optional positional and named parameters.
|
|
}
|
|
}
|
|
|
|
extension on String Function(int) {
|
|
int get fu => 5;
|
|
}
|
|
|
|
extension on FutureOr<int> {
|
|
int get fi => 6;
|
|
|
|
void testFutureOr() {
|
|
var self = this;
|
|
// The `this` type can be type-promoted to both Future<int> and int.
|
|
if (self is Future<int>) {
|
|
self.then((int x) {});
|
|
} else if (self is int) {
|
|
self + 2;
|
|
}
|
|
}
|
|
}
|
|
|
|
extension on FutureOr<Object?> {
|
|
int get fo => 7;
|
|
}
|
|
|
|
extension on FutureOr<Future<Object?>> {
|
|
int get ffo => 8;
|
|
}
|
|
|
|
extension on FutureOr<Null> {
|
|
int get fn => 9;
|
|
}
|
|
|
|
extension on Null {
|
|
int get n => 10;
|
|
}
|
|
|
|
// TODO: Type `Never` when it's added.
|
|
|
|
extension<T> on FutureOr<T> {
|
|
Type get futureType => T;
|
|
}
|
|
|
|
extension<R, T> on R Function(T) {
|
|
Type get returnType => R;
|
|
Type get parameterType => T;
|
|
}
|