| // Copyright (c) 2017, 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. |
| |
| import 'package:front_end/src/api_prototype/memory_file_system.dart'; |
| import 'package:front_end/src/base/libraries_specification.dart'; |
| |
| final _ASYNC = r''' |
| library dart.async; |
| |
| class Future<T> { |
| factory Future(computation()) => null; |
| factory Future.delayed(Duration duration, [T computation()]) => null; |
| factory Future.microtask(FutureOr<T> computation()) => null; |
| factory Future.value([value]) => null; |
| |
| static Future<List<T>> wait<T>(Iterable<Future<T>> futures) => null; |
| Future<R> then<R>(FutureOr<R> onValue(T value)) => null; |
| |
| Future<T> whenComplete(action()); |
| } |
| |
| |
| class FutureOr<T> {} |
| class Stream<T> {} |
| abstract class StreamIterator<T> {} |
| |
| abstract class Completer<T> { |
| factory Completer() => null; |
| factory Completer.sync() => null; |
| Future<T> get future; |
| void complete([FutureOr<T> value]); |
| void completeError(Object error, [StackTrace stackTrace]); |
| bool get isCompleted; |
| } |
| |
| class _StreamIterator<T> implements StreamIterator<T> { |
| T get current; |
| Future<bool> moveNext(); |
| Future cancel(); |
| } |
| |
| class _AsyncStarStreamController<T> { |
| Stream<T> get stream; |
| bool add(T event); |
| bool addStream(Stream<T> stream); |
| void addError(Object error, StackTrace stackTrace); |
| close(); |
| } |
| |
| Object _asyncStackTraceHelper(Function async_op) { } |
| Function _asyncThenWrapperHelper(continuation) {} |
| Function _asyncErrorWrapperHelper(continuation) {} |
| Future _awaitHelper( |
| object, Function thenCallback, Function errorCallback, var awaiter) {} |
| '''; |
| |
| final _CORE = r''' |
| library dart.core; |
| import 'dart:_internal'; |
| import 'dart:async'; |
| |
| class Object { |
| const Object(); |
| bool operator ==(other) => identical(this, other); |
| String toString() => 'a string'; |
| int get hashCode => 0; |
| Type get runtimeType => null; |
| dynamic noSuchMethod(Invocation invocation) => null; |
| } |
| |
| class Null {} |
| |
| class Symbol { |
| const factory Symbol(String name) { |
| return null; |
| } |
| } |
| |
| class Type {} |
| |
| abstract class Comparable<T> { |
| int compareTo(T other); |
| } |
| |
| abstract class Pattern {} |
| |
| abstract class String implements Comparable<String>, Pattern { |
| external factory String.fromCharCodes(Iterable<int> charCodes, |
| [int start = 0, int end]); |
| String operator +(String other) => null; |
| bool get isEmpty => false; |
| bool get isNotEmpty => false; |
| int get length => 0; |
| String substring(int len) => null; |
| String toLowerCase(); |
| String toUpperCase(); |
| List<int> get codeUnits; |
| } |
| |
| abstract class RegExp implements Pattern { |
| external factory RegExp(String source); |
| } |
| |
| class Function {} |
| class Invocation {} |
| class StackTrace {} |
| |
| class bool extends Object { |
| external const factory bool.fromEnvironment(String name, |
| {bool defaultValue: false}); |
| } |
| |
| abstract class num implements Comparable<num> { |
| bool operator ==(Object other); |
| bool operator <(num other); |
| bool operator <=(num other); |
| bool operator >(num other); |
| bool operator >=(num other); |
| num operator +(num other); |
| num operator -(num other); |
| num operator *(num other); |
| num operator /(num other); |
| int operator ^(int other); |
| int operator |(int other); |
| int operator <<(int other); |
| int operator >>(int other); |
| int operator ~/(num other); |
| num operator %(num other); |
| int operator ~(); |
| num operator -(); |
| int toInt(); |
| double toDouble(); |
| num abs(); |
| int round(); |
| } |
| |
| abstract class int extends num { |
| external const factory int.fromEnvironment(String name, {int defaultValue}); |
| |
| bool get isNegative; |
| bool get isEven => false; |
| |
| int operator &(int other); |
| int operator |(int other); |
| int operator ^(int other); |
| int operator ~(); |
| int operator <<(int shiftAmount); |
| int operator >>(int shiftAmount); |
| |
| int operator -(); |
| |
| external static int parse(String source, |
| { int radix, |
| int onError(String source) }); |
| } |
| |
| abstract class double extends num { |
| static const double NAN = 0.0 / 0.0; |
| static const double INFINITY = 1.0 / 0.0; |
| static const double NEGATIVE_INFINITY = -INFINITY; |
| static const double MIN_POSITIVE = 5e-324; |
| static const double MAX_FINITE = 1.7976931348623157e+308; |
| |
| double remainder(num other); |
| double operator +(num other); |
| double operator -(num other); |
| double operator *(num other); |
| double operator %(num other); |
| double operator /(num other); |
| int operator ~/(num other); |
| double operator -(); |
| double abs(); |
| double get sign; |
| int round(); |
| int floor(); |
| int ceil(); |
| int truncate(); |
| double roundToDouble(); |
| double floorToDouble(); |
| double ceilToDouble(); |
| double truncateToDouble(); |
| external static double parse(String source, |
| [double onError(String source)]); |
| } |
| |
| class Iterator<E> { |
| bool moveNext(); |
| E get current; |
| } |
| |
| abstract class Iterable<E> { |
| Iterator<E> get iterator; |
| bool get isEmpty; |
| E get first; |
| |
| Iterable<R> map<R>(R f(E e)); |
| |
| R fold<R>(R initialValue, R combine(R previousValue, E element)); |
| |
| Iterable<T> expand<T>(Iterable<T> f(E element)); |
| |
| Iterable<E> where(bool test(E element)); |
| |
| void forEach(void f(E element)); |
| |
| List<E> toList(); |
| } |
| |
| class List<E> implements Iterable<E> { |
| List(); |
| factory List.from(Iterable elements, {bool growable: true}) => null; |
| void add(E value) {} |
| void addAll(Iterable<E> iterable) {} |
| E operator [](int index) => null; |
| void operator []=(int index, E value) {} |
| Iterator<E> get iterator => null; |
| void clear() {} |
| |
| bool get isEmpty => false; |
| E get first => null; |
| E get last => null; |
| |
| R fold<R>(R initialValue, R combine(R previousValue, E element)) => null; |
| } |
| |
| class Map<K, V> extends Object { |
| V operator [](K key) => null; |
| void operator []=(K key, V value) {} |
| Iterable<K> get keys => null; |
| int get length; |
| Iterable<V> get values; |
| } |
| |
| class Duration implements Comparable<Duration> {} |
| |
| external bool identical(Object a, Object b); |
| |
| void print(Object o) {} |
| |
| abstract class _SyncIterable<T> implements Iterable<T> {} |
| |
| class _SyncIterator<T> implements Iterator<T> { |
| T _current; |
| Iterable<T> _yieldEachIterable; |
| } |
| |
| class _InvocationMirror { |
| _InvocationMirror._withoutType( |
| String _functionName, List<Type> _typeArguments, |
| List _positionalArguments, Map<Symbol, dynamic>_namedArguments, |
| bool _isSuperInvocation); |
| } |
| |
| class _CompileTimeError { |
| final String _errorMsg; |
| _CompileTimeError(this._errorMsg); |
| } |
| |
| class _ConstantExpressionError { |
| const _ConstantExpressionError(); |
| external _throw(error); |
| } |
| |
| class _DuplicatedFieldInitializerError { |
| _DuplicatedFieldInitializerError(String name); |
| } |
| |
| class AbstractClassInstantiationError { |
| AbstractClassInstantiationError(String className); |
| } |
| |
| class FallThroughError { |
| FallThroughError(); |
| FallThroughError._create(String url, int line); |
| } |
| '''; |
| |
| /// Create SDK libraries which are used by Fasta to perform kernel generation. |
| /// The root of the SDK is `org-dartlang-test:///sdk`, it will contain a |
| /// libraries specification file at `lib/libraries.json`. |
| /// |
| /// Returns the [TargetLibrariesSpecification] whose contents are in |
| /// libraries.json. |
| TargetLibrariesSpecification createSdkFiles(MemoryFileSystem fileSystem) { |
| Map<String, LibraryInfo> dartLibraries = {}; |
| void addSdkLibrary(String name, String contents) { |
| String path = '$name/$name.dart'; |
| Uri uri = Uri.parse('org-dartlang-test:///sdk/lib/$path'); |
| fileSystem.entityForUri(uri).writeAsStringSync(contents); |
| dartLibraries[name] = new LibraryInfo(name, uri, const []); |
| } |
| |
| fileSystem |
| .entityForUri(Uri.parse('org-dartlang-test:///sdk/')) |
| .createDirectory(); |
| |
| addSdkLibrary('core', _CORE); |
| addSdkLibrary('async', _ASYNC); |
| |
| addSdkLibrary('collection', 'library dart.collection;'); |
| addSdkLibrary('convert', 'library dart.convert;'); |
| addSdkLibrary('developer', 'library dart.developer;'); |
| addSdkLibrary('io', 'library dart.io;'); |
| addSdkLibrary('cli', 'library dart.cli;'); |
| addSdkLibrary('isolate', 'library dart.isolate;'); |
| addSdkLibrary('math', ''' |
| library dart.math; |
| external double sin(num radians); |
| '''); |
| addSdkLibrary('mirrors', 'library dart.mirrors;'); |
| addSdkLibrary('nativewrappers', 'library dart.nativewrappers;'); |
| addSdkLibrary('profiler', 'library dart.profiler;'); |
| addSdkLibrary('typed_data', 'library dart.typed_data;'); |
| addSdkLibrary('_builtin', 'library dart._builtin;'); |
| addSdkLibrary('_vmservice', 'library dart._vmservice;'); |
| addSdkLibrary('vmservice_io', 'library dart.vmservice_io;'); |
| addSdkLibrary('_internal', ''' |
| library dart._internal; |
| class Symbol {} |
| class ExternalName { |
| final String name; |
| const ExternalName(this.name); |
| } |
| '''); |
| |
| var targetSpec = new TargetLibrariesSpecification(null, dartLibraries); |
| var spec = new LibrariesSpecification({'none': targetSpec, 'vm': targetSpec}); |
| |
| Uri uri = Uri.parse('org-dartlang-test:///sdk/lib/libraries.json'); |
| fileSystem.entityForUri(uri).writeAsStringSync(spec.toJsonString(uri)); |
| return targetSpec; |
| } |