mirror of
https://github.com/flutter/flutter.git
synced 2026-02-20 02:29:02 +08:00
108 lines
3.3 KiB
Markdown
108 lines
3.3 KiB
Markdown
Sky Script Language
|
|
===================
|
|
|
|
The Sky script language is Dart.
|
|
|
|
The way that Sky integrates the module system with its script language
|
|
is described in [modules.md](modules.md).
|
|
|
|
When an method defined as ``external`` receives an argument, it must
|
|
type-check it, and, if the argument's value is the wrong type, then it
|
|
must throw an ArgumentError as follows:
|
|
|
|
throw new ArgumentError(value, name: name);
|
|
|
|
...where "name" is the name of the argument.
|
|
|
|
Further, if the type of the argument is annotated with ``@nonnull``,
|
|
then the method must additionally throw if the value is of type Null,
|
|
as follows:
|
|
|
|
throw new ArgumentError.notNull(name);
|
|
|
|
The ``@nonnull`` annotation is defined as follows:
|
|
|
|
```dart
|
|
const nonnull = const Object();
|
|
```
|
|
|
|
The ``@nonnull`` annotation does nothing in code not marked
|
|
``external``, but it has been included anyway for documentation
|
|
purposes. It indicates places where providing a null is a contract
|
|
violation and that results are therefore likely to be poor.
|
|
|
|
The following definitions are exposed in ``sky:core``:
|
|
|
|
```dart
|
|
abstract class AutomaticMetadata {
|
|
const AutomaticMetadata();
|
|
void init(DeclarationMirror target, Module module);
|
|
|
|
static void runLibrary(LibraryMirror library, Module module) {
|
|
library.declarations.values.toList()..sort((DeclarationMirror a, DeclarationMirror b) {
|
|
bool aHasLocation;
|
|
try {
|
|
aHasLocation = a.location != null;
|
|
} catch(e) {
|
|
aHasLocation = false;
|
|
}
|
|
bool bHasLocation;
|
|
try {
|
|
bHasLocation = b.location != null;
|
|
} catch(e) {
|
|
bHasLocation = false;
|
|
}
|
|
if (!aHasLocation)
|
|
return bHasLocation ? 1 : 0;
|
|
if (!bHasLocation)
|
|
return -1;
|
|
if (a.location.sourceUri != b.location.sourceUri)
|
|
return a.location.sourceUri.toString().compareTo(b.location.sourceUri.toString());
|
|
if (a.location.line != b.location.line)
|
|
return a.location.line - b.location.line;
|
|
return a.location.column - b.location.column;
|
|
})
|
|
..forEach((DeclarationMirror d) {
|
|
d.metadata.forEach((InstanceMirror i) {
|
|
if (i.reflectee is AutomaticMetadata)
|
|
i.reflectee.run(d, module);
|
|
});
|
|
});
|
|
}
|
|
}
|
|
|
|
class AutomaticFunction extends AutomaticMetadata {
|
|
const AutomaticFunction();
|
|
void init(DeclarationMirror target, Module module) {
|
|
assert(target is MethodMirror);
|
|
MethodMirror f = target as MethodMirror;
|
|
assert(!f.isAbstract);
|
|
assert(f.isRegularMethod);
|
|
assert(f.isTopLevel);
|
|
assert(f.isStatic);
|
|
assert(f.parameters.length == 0);
|
|
assert(f.returnType == currentMirrorSystem().voidType);
|
|
(f.owner as LibraryMirror).invoke(f.simpleName, []);
|
|
}
|
|
}
|
|
const autorun = const AutomaticFunction();
|
|
```
|
|
|
|
Extensions
|
|
----------
|
|
|
|
The following as-yet unimplemented features of the Dart language are
|
|
assumed to exist:
|
|
|
|
* It is assumed that a subclass can define a constructor by reference
|
|
to a superclass' constructor, wherein the subclass' constructor has
|
|
the same arguments as the superclass' constructor and does nothing
|
|
but invoke that superclass' constructor with the same arguments. The
|
|
syntax for defining this is, within the class body for a class
|
|
called ClassName:
|
|
|
|
```dart
|
|
ClassName = SuperclassName;
|
|
ClassName.namedConstructor = SuperclassName.otherNamedConstructor;
|
|
```
|