sigmund@google.com
ca7d09eea3
R=jmesserly@google.com Review URL: https://codereview.chromium.org//208743006 git-svn-id: https://dart.googlecode.com/svn/branches/bleeding_edge/dart@34461 260f80e4-7a28-3924-810f-c04153c831b5
463 lines
17 KiB
Dart
463 lines
17 KiB
Dart
// Copyright (c) 2014, 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 to generate code that can initialize the `StaticConfiguration` in
|
|
/// `package:smoke/static.dart`.
|
|
///
|
|
/// This library doesn't have any specific logic to extract information from
|
|
/// Dart source code. To extract code using the analyzer, take a look at the
|
|
/// `smoke.codegen.recorder` library.
|
|
library smoke.codegen.generator;
|
|
|
|
import 'dart:collection' show SplayTreeMap, SplayTreeSet;
|
|
|
|
import 'package:smoke/src/common.dart' show compareLists, compareMaps;
|
|
|
|
/// Collects the necessary information and generates code to initialize a
|
|
/// `StaticConfiguration`. After setting up the generator by calling
|
|
/// [addGetter], [addSetter], [addSymbol], and [addDeclaration], you can
|
|
/// retrieve the generated code using the following three methods:
|
|
///
|
|
/// * [writeImports] writes a list of imports directives,
|
|
/// * [writeTopLevelDeclarations] writes additional declarations used to
|
|
/// represent mixin classes by name in the generated code.
|
|
/// * [writeInitCall] writes the actual code that allocates the static
|
|
/// configuration.
|
|
///
|
|
/// You'd need to include all three in your generated code, since the
|
|
/// initialization code refers to symbols that are only available from the
|
|
/// generated imports or the generated top-level declarations.
|
|
class SmokeCodeGenerator {
|
|
// Note: we use SplayTreeSet/Map here and below to keep generated code sorted.
|
|
/// Names used as getters via smoke.
|
|
final Set<String> _getters = new SplayTreeSet();
|
|
|
|
/// Names used as setters via smoke.
|
|
final Set<String> _setters = new SplayTreeSet();
|
|
|
|
/// Subclass relations needed to run smoke queries.
|
|
final Map<TypeIdentifier, TypeIdentifier> _parents = new SplayTreeMap();
|
|
|
|
/// Declarations requested via `smoke.getDeclaration or `smoke.query`.
|
|
final Map<TypeIdentifier, Map<String, _DeclarationCode>> _declarations =
|
|
new SplayTreeMap();
|
|
|
|
/// Static methods used on each type.
|
|
final Map<TypeIdentifier, Set<String>> _staticMethods = new SplayTreeMap();
|
|
|
|
/// Names that are used both as strings and symbols.
|
|
final Set<String> _names = new SplayTreeSet();
|
|
|
|
/// Prefixes associated with imported libraries.
|
|
final Map<String, String> _libraryPrefix = {};
|
|
|
|
/// Register that [name] is used as a getter in the code.
|
|
void addGetter(String name) { _getters.add(name); }
|
|
|
|
/// Register that [name] is used as a setter in the code.
|
|
void addSetter(String name) { _setters.add(name); }
|
|
|
|
/// Register that [name] might be needed as a symbol.
|
|
void addSymbol(String name) { _names.add(name); }
|
|
|
|
/// Register that `cls.name` is used as a static method in the code.
|
|
void addStaticMethod(TypeIdentifier cls, String name) {
|
|
var methods = _staticMethods.putIfAbsent(cls,
|
|
() => new SplayTreeSet<String>());
|
|
_addLibrary(cls.importUrl);
|
|
methods.add(name);
|
|
}
|
|
|
|
int _mixins = 0;
|
|
|
|
/// Creates a new type to represent a mixin. Use [comment] to help users
|
|
/// figure out what mixin is being represented.
|
|
TypeIdentifier createMixinType([String comment = '']) =>
|
|
new TypeIdentifier(null, '_M${_mixins++}', comment);
|
|
|
|
/// Register that we care to know that [child] extends [parent].
|
|
void addParent(TypeIdentifier child, TypeIdentifier parent) {
|
|
var existing = _parents[child];
|
|
if (existing != null) {
|
|
if (existing == parent) return;
|
|
throw new StateError('$child already has a different parent associated'
|
|
'($existing instead of $parent)');
|
|
}
|
|
_addLibrary(child.importUrl);
|
|
_addLibrary(parent.importUrl);
|
|
_parents[child] = parent;
|
|
}
|
|
|
|
/// Register a declaration of a field, property, or method. Note that one and
|
|
/// only one of [isField], [isMethod], or [isProperty] should be set at a
|
|
/// given time.
|
|
void addDeclaration(TypeIdentifier cls, String name, TypeIdentifier type,
|
|
{bool isField: false, bool isProperty: false, bool isMethod: false,
|
|
bool isFinal: false, bool isStatic: false,
|
|
List<ConstExpression> annotations: const []}) {
|
|
final count = (isField ? 1 : 0) + (isProperty ? 1 : 0) + (isMethod ? 1 : 0);
|
|
if (count != 1) {
|
|
throw new ArgumentError('Declaration must be one (and only one) of the '
|
|
'following: a field, a property, or a method.');
|
|
}
|
|
var kind = isField ? 'FIELD' : isProperty ? 'PROPERTY' : 'METHOD';
|
|
_declarations.putIfAbsent(cls,
|
|
() => new SplayTreeMap<String, _DeclarationCode>());
|
|
_addLibrary(cls.importUrl);
|
|
var map = _declarations[cls];
|
|
|
|
for (var exp in annotations) {
|
|
for (var lib in exp.librariesUsed) {
|
|
_addLibrary(lib);
|
|
}
|
|
}
|
|
|
|
_addLibrary(type.importUrl);
|
|
var decl = new _DeclarationCode(name, type, kind, isFinal, isStatic,
|
|
annotations);
|
|
if (map.containsKey(name) && map[name] != decl) {
|
|
throw new StateError('$type.$name already has a different declaration'
|
|
' (${map[name]} instead of $decl).');
|
|
}
|
|
map[name] = decl;
|
|
}
|
|
|
|
/// Register that we might try to read declarations of [type], even if no
|
|
/// declaration exists. This informs the smoke system that querying for a
|
|
/// member in this class might be intentional and not an error.
|
|
void addEmptyDeclaration(TypeIdentifier type) {
|
|
_addLibrary(type.importUrl);
|
|
_declarations.putIfAbsent(type,
|
|
() => new SplayTreeMap<String, _DeclarationCode>());
|
|
}
|
|
|
|
/// Writes to [buffer] a line for each import that is needed by the generated
|
|
/// code. The code added by [writeInitCall] depends on these imports.
|
|
void writeImports(StringBuffer buffer) {
|
|
DEFAULT_IMPORTS.forEach((i) => buffer.writeln(i));
|
|
_libraryPrefix.forEach((url, prefix) {
|
|
buffer.writeln("import '$url' as $prefix;");
|
|
});
|
|
}
|
|
|
|
/// Writes to [buffer] top-level declarations that are used by the code
|
|
/// generated in [writeInitCall]. These are typically declarations of empty
|
|
/// classes that are then used as placeholders for mixin superclasses.
|
|
void writeTopLevelDeclarations(StringBuffer buffer) {
|
|
var types = new Set()
|
|
..addAll(_parents.keys)
|
|
..addAll(_parents.values)
|
|
..addAll(_declarations.keys)
|
|
..addAll(_declarations.values.expand(
|
|
(m) => m.values.map((d) => d.type)))
|
|
..removeWhere((t) => t.importUrl != null);
|
|
for (var type in types) {
|
|
buffer.write('abstract class ${type.name} {}');
|
|
if (type.comment != null) buffer.write(' // ${type.comment}');
|
|
buffer.writeln();
|
|
}
|
|
}
|
|
|
|
/// Appends to [buffer] code that will initialize smoke's static
|
|
/// configuration. For example, the code might be of the form:
|
|
///
|
|
/// useGeneratedCode(new StaticConfiguration(
|
|
/// getters: {
|
|
/// #i: (o) => o.i,
|
|
/// ...
|
|
/// names: {
|
|
/// #i: "i",
|
|
/// }));
|
|
///
|
|
/// The optional [indent] argument is used for formatting purposes. All
|
|
/// entries in each map (getters, setters, names, declarations, parents) are
|
|
/// sorted alphabetically.
|
|
///
|
|
/// **Note**: this code assumes that imports from [writeImports] and top-level
|
|
/// declarations from [writeTopLevelDeclarations] are included in the same
|
|
/// library where this code will live.
|
|
void writeInitCall(StringBuffer buffer, [int indent = 2]) {
|
|
final spaces = new List.filled(indent, ' ').join('');
|
|
var args = {};
|
|
|
|
if (_getters.isNotEmpty) {
|
|
args['getters'] = _getters.map((n) => '${_symbol(n)}: (o) => o.$n');
|
|
}
|
|
if (_setters.isNotEmpty) {
|
|
args['setters'] = _setters.map(
|
|
(n) => '${_symbol(n)}: (o, v) { o.$n = v; }');
|
|
}
|
|
|
|
if (_parents.isNotEmpty) {
|
|
var parentsMap = [];
|
|
_parents.forEach((child, parent) {
|
|
var parent = _parents[child];
|
|
parentsMap.add('${child.asCode(_libraryPrefix)}: '
|
|
'${parent.asCode(_libraryPrefix)}');
|
|
});
|
|
args['parents'] = parentsMap;
|
|
}
|
|
|
|
if (_declarations.isNotEmpty) {
|
|
var declarations = [];
|
|
_declarations.forEach((type, members) {
|
|
final sb = new StringBuffer()
|
|
..write(type.asCode(_libraryPrefix))
|
|
..write(': ');
|
|
if (members.isEmpty) {
|
|
sb.write('const {}');
|
|
} else {
|
|
sb.write('{\n');
|
|
members.forEach((name, decl) {
|
|
var decl = members[name].asCode(_libraryPrefix);
|
|
sb.write('$spaces ${_symbol(name)}: $decl,\n');
|
|
});
|
|
sb.write('$spaces }');
|
|
}
|
|
declarations.add(sb.toString());
|
|
});
|
|
args['declarations'] = declarations;
|
|
}
|
|
|
|
if (_staticMethods.isNotEmpty) {
|
|
var methods = [];
|
|
_staticMethods.forEach((type, members) {
|
|
var className = type.asCode(_libraryPrefix);
|
|
final sb = new StringBuffer()
|
|
..write(className)
|
|
..write(': ');
|
|
if (members.isEmpty) {
|
|
sb.write('const {}');
|
|
} else {
|
|
sb.write('{\n');
|
|
for (var name in members) {
|
|
sb.write('$spaces ${_symbol(name)}: $className.$name,\n');
|
|
}
|
|
sb.write('$spaces }');
|
|
}
|
|
methods.add(sb.toString());
|
|
});
|
|
args['staticMethods'] = methods;
|
|
}
|
|
|
|
if (_names.isNotEmpty) {
|
|
args['names'] = _names.map((n) => "${_symbol(n)}: r'$n'");
|
|
}
|
|
|
|
buffer..write(spaces)
|
|
..writeln('useGeneratedCode(new StaticConfiguration(')
|
|
..write('$spaces checkedMode: false');
|
|
|
|
args.forEach((name, mapContents) {
|
|
buffer.writeln(',');
|
|
// TODO(sigmund): use const map when Type can be keys (dartbug.com/17123)
|
|
buffer.writeln('$spaces $name: {');
|
|
for (var entry in mapContents) {
|
|
buffer.writeln('$spaces $entry,');
|
|
}
|
|
buffer.write('$spaces }');
|
|
});
|
|
buffer.writeln('));');
|
|
}
|
|
|
|
/// Adds a library that needs to be imported.
|
|
void _addLibrary(String url) {
|
|
if (url == null || url == 'dart:core') return;
|
|
_libraryPrefix.putIfAbsent(url, () => 'smoke_${_libraryPrefix.length}');
|
|
}
|
|
}
|
|
|
|
/// Information used to generate code that allocates a `Declaration` object.
|
|
class _DeclarationCode extends ConstExpression {
|
|
final String name;
|
|
final TypeIdentifier type;
|
|
final String kind;
|
|
final bool isFinal;
|
|
final bool isStatic;
|
|
final List<ConstExpression> annotations;
|
|
|
|
_DeclarationCode(this.name, this.type, this.kind, this.isFinal, this.isStatic,
|
|
this.annotations);
|
|
|
|
List<String> get librariesUsed => []
|
|
..addAll(type.librariesUsed)
|
|
..addAll(annotations.expand((a) => a.librariesUsed));
|
|
|
|
String asCode(Map<String, String> libraryPrefixes) {
|
|
var sb = new StringBuffer();
|
|
sb.write('const Declaration(${_symbol(name)}, '
|
|
'${type.asCode(libraryPrefixes)}');
|
|
if (kind != 'FIELD') sb.write(', kind: $kind');
|
|
if (isFinal) sb.write(', isFinal: true');
|
|
if (isStatic) sb.write(', isStatic: true');
|
|
if (annotations != null && annotations.isNotEmpty) {
|
|
sb.write(', annotations: const [');
|
|
bool first = true;
|
|
for (var e in annotations) {
|
|
if (!first) sb.write(', ');
|
|
first = false;
|
|
sb.write(e.asCode(libraryPrefixes));
|
|
}
|
|
sb.write(']');
|
|
}
|
|
sb.write(')');
|
|
return sb.toString();
|
|
}
|
|
|
|
String toString() =>
|
|
'(decl: $type.$name - $kind, $isFinal, $isStatic, $annotations)';
|
|
operator== (other) => other is _DeclarationCode && name == other.name &&
|
|
type == other.type && kind == other.kind && isFinal == other.isFinal &&
|
|
isStatic == other.isStatic &&
|
|
compareLists(annotations, other.annotations);
|
|
int get hashCode => name.hashCode + (31 * type.hashCode);
|
|
}
|
|
|
|
/// A constant expression that can be used as an annotation.
|
|
abstract class ConstExpression {
|
|
|
|
/// Returns the library URLs that needs to be imported for this
|
|
/// [ConstExpression] to be a valid annotation.
|
|
List<String> get librariesUsed;
|
|
|
|
/// Return a string representation of the code in this expression.
|
|
/// [libraryPrefixes] describes what prefix has been associated with each
|
|
/// import url mentioned in [libraryUsed].
|
|
String asCode(Map<String, String> libraryPrefixes);
|
|
|
|
ConstExpression();
|
|
|
|
/// Create a string expression of the form `'string'`, where [string] is
|
|
/// normalized so we can correctly wrap it in single quotes.
|
|
factory ConstExpression.string(String string) {
|
|
var value = string.replaceAll(r'\', r'\\').replaceAll(r"'", r"\'");
|
|
return new CodeAsConstExpression("'$value'");
|
|
}
|
|
|
|
/// Create an expression of the form `prefix.variable_name`.
|
|
factory ConstExpression.identifier(String importUrl, String name) =>
|
|
new TopLevelIdentifier(importUrl, name);
|
|
|
|
/// Create an expression of the form `prefix.Constructor(v1, v2, p3: v3)`.
|
|
factory ConstExpression.constructor(String importUrl, String name,
|
|
List<ConstExpression> positionalArgs,
|
|
Map<String, ConstExpression> namedArgs) =>
|
|
new ConstructorExpression(importUrl, name, positionalArgs, namedArgs);
|
|
}
|
|
|
|
/// A constant expression written as a String. Used when the code is self
|
|
/// contained and it doesn't depend on any imported libraries.
|
|
class CodeAsConstExpression extends ConstExpression {
|
|
String code;
|
|
List<String> get librariesUsed => const [];
|
|
|
|
CodeAsConstExpression(this.code);
|
|
|
|
String asCode(Map<String, String> libraryPrefixes) => code;
|
|
|
|
String toString() => '(code: $code)';
|
|
operator== (other) => other is CodeAsConstExpression && code == other.code;
|
|
int get hashCode => code.hashCode;
|
|
}
|
|
|
|
/// Describes a reference to some symbol that is exported from a library. This
|
|
/// is typically used to refer to a type or a top-level variable from that
|
|
/// library.
|
|
class TopLevelIdentifier extends ConstExpression {
|
|
final String importUrl;
|
|
final String name;
|
|
TopLevelIdentifier(this.importUrl, this.name);
|
|
|
|
List<String> get librariesUsed => [importUrl];
|
|
String asCode(Map<String, String> libraryPrefixes) {
|
|
if (importUrl == 'dart:core' || importUrl == null) return name;
|
|
return '${libraryPrefixes[importUrl]}.$name';
|
|
}
|
|
|
|
String toString() => '(identifier: $importUrl, $name)';
|
|
operator== (other) => other is TopLevelIdentifier && name == other.name
|
|
&& importUrl == other.importUrl;
|
|
int get hashCode => 31 * importUrl.hashCode + name.hashCode;
|
|
}
|
|
|
|
/// Represents an expression that invokes a const constructor.
|
|
class ConstructorExpression extends ConstExpression {
|
|
final String importUrl;
|
|
final String name;
|
|
final List<ConstExpression> positionalArgs;
|
|
final Map<String, ConstExpression> namedArgs;
|
|
ConstructorExpression(this.importUrl, this.name, this.positionalArgs,
|
|
this.namedArgs);
|
|
|
|
List<String> get librariesUsed => [importUrl]
|
|
..addAll(positionalArgs.expand((e) => e.librariesUsed))
|
|
..addAll(namedArgs.values.expand((e) => e.librariesUsed));
|
|
|
|
String asCode(Map<String, String> libraryPrefixes) {
|
|
var sb = new StringBuffer();
|
|
sb.write('const ');
|
|
if (importUrl != 'dart:core' && importUrl != null) {
|
|
sb.write('${libraryPrefixes[importUrl]}.');
|
|
}
|
|
sb.write('$name(');
|
|
bool first = true;
|
|
for (var e in positionalArgs) {
|
|
if (!first) sb.write(', ');
|
|
first = false;
|
|
sb.write(e.asCode(libraryPrefixes));
|
|
}
|
|
namedArgs.forEach((name, value) {
|
|
if (!first) sb.write(', ');
|
|
first = false;
|
|
sb.write('$name: ');
|
|
sb.write(value.asCode(libraryPrefixes));
|
|
});
|
|
sb.write(')');
|
|
return sb.toString();
|
|
}
|
|
|
|
String toString() => '(ctor: $importUrl, $name, $positionalArgs, $namedArgs)';
|
|
operator== (other) => other is ConstructorExpression && name == other.name
|
|
&& importUrl == other.importUrl &&
|
|
compareLists(positionalArgs, other.positionalArgs) &&
|
|
compareMaps(namedArgs, other.namedArgs);
|
|
int get hashCode => 31 * importUrl.hashCode + name.hashCode;
|
|
}
|
|
|
|
|
|
/// Describes a type identifier, with the library URL where the type is defined.
|
|
// TODO(sigmund): consider adding support for imprecise TypeIdentifiers, which
|
|
// may be used by tools that want to generate code without using the analyzer
|
|
// (they can syntactically tell the type comes from one of N imports).
|
|
class TypeIdentifier extends TopLevelIdentifier
|
|
implements Comparable<TypeIdentifier> {
|
|
final String comment;
|
|
TypeIdentifier(importUrl, typeName, [this.comment])
|
|
: super(importUrl, typeName);
|
|
|
|
// We implement [Comparable] to sort out entries in the generated code.
|
|
int compareTo(TypeIdentifier other) {
|
|
if (importUrl == null && other.importUrl != null) return 1;
|
|
if (importUrl != null && other.importUrl == null) return -1;
|
|
var c1 = importUrl == null ? 0 : importUrl.compareTo(other.importUrl);
|
|
return c1 != 0 ? c1 : name.compareTo(other.name);
|
|
}
|
|
|
|
String toString() => '(type-identifier: $importUrl, $name, $comment)';
|
|
bool operator ==(other) => other is TypeIdentifier &&
|
|
importUrl == other.importUrl && name == other.name &&
|
|
comment == other.comment;
|
|
int get hashCode => super.hashCode;
|
|
}
|
|
|
|
/// Default set of imports added by [SmokeCodeGenerator].
|
|
const DEFAULT_IMPORTS = const [
|
|
"import 'package:smoke/smoke.dart' show Declaration, PROPERTY, METHOD;",
|
|
"import 'package:smoke/static.dart' show "
|
|
"useGeneratedCode, StaticConfiguration;",
|
|
];
|
|
|
|
_symbol(String name) =>
|
|
name.contains('[') ? "const Symbol('$name')" : '#$name';
|