code_builder 2.0.0-beta

code_builder: ^2.0.0-beta copied to clipboard

• Added lazySpec and lazyCode to lazily create code on visit #145.

• BUG FIX: equalsDart emits the failing source code #147.

• BUG FIX: Top-level lambda Methods no longer emit invalid code #146.

• Added Expression.annotation and Expression.annotationNamed.

• Added Method.closure to create an Expression.

• Added FunctionType.

• Added {new|const}InstanceNamed to Expression #135.

  • Also added a typeArguments option to all invocations.

• Added assign{...} variants to Expression #137.

• Added .awaited and .returned to Expression #138.

• BUG FIX: Block now implements Code #136.

• BUG FIX: new DartEmitter.scoped() applies prefixing #139.

• Renamed many of the .asFoo(...) and .toFoo(...) methods to single getter:

  • asCode() to code
  • asStatement() to statement
  • toExpression() to expression

• Moved {new|const}Instance{[Named]} from Expression to Reference.

• Upgraded build_runner from ^0.3.0 to >=0.4.0 <0.6.0.

• Upgraded build_value{_generator} from ^1.0.0 to >=2.0.0 <5.0.0.

• Upgraded source_gen from >=0.5.0 <0.7.0 to ^0.7.0.

• Added MethodModifier to allow emit a Method with async|async*|sync*.

• Added show|hide to Directive.

• Added Directive.importDeferredAs.

• Added a new line character after emitting some types (class, method, etc).

• Added refer as a short-hand for new Reference(...).

  • Reference now implements Expression.

• Added many classes/methods for writing bodies of Code fluently:

  • Expression
  • LiteralExpression
    • literal
    • literalNull
    • literalBool
    • literalTrue
    • literalFalse
    • literalNum
    • literalString
    • literalList and literalConstList
    • literalMap and literalConstMap
  • const Code(staticString)
  • const Code.scope((allocate) => '')

• Removed SimpleSpecVisitor (it was unused).

• Removed implements Reference from Method and Field; not a lot of value.

• SpecVisitor<T>'s methods all have an optional [T context] parameter now.

  • This makes it much easier to avoid allocating extra StringBuffers.

• equalsDart removes insignificant white space before comparing results.

• Removed Reference.localScope. Just use Reference(symbol) now.
• Allow Reference instead of an explicit TypeReference in most APIs.
  • toType() is performed for you as part the emitter process

final animal = new Class((b) => b
  ..name = 'Animal'
  // Used to need a suffix of .toType().
  ..extend = const Reference('Organism')
  ..methods.add(new Method.returnsVoid((b) => b
    ..name = 'eat'
    ..lambda = true
    ..body = new Code((b) => b..code = 'print(\'Yum\')'))));

• We now support the Dart 2.0 pre-release SDKs (<2.0.0-dev.infinity)
• Removed the ability to treat Class as a TypeReference.
  • Was required for compilation to dart2js, which is now tested on travis.

• Complete re-write to not use package:analyzer.
• Code generation now properly uses the builder pattern (via built_value).
• See examples and tests for details.

• Added isInstanceOf to ExpressionBuilder, which performs an is check:

expect(
  reference('foo').isInstanceOf(_barType), 
  equalsSource('foo is Bar'),
);

• Support latest pkg/analyzer and pkg/func.

• Update internals to use newer analyzer API

• Support the latest version of package:dart_style.

First full release. At this point all changes until 2.0.0 will be backwards compatible (new features) or bug fixes that are not breaking. This doesn't mean that the entire Dart language is buildable with our API, though.

Contributions are welcome.

• Exposed uri in ImportBuilder, ExportBuilder, and Part[Of]Builder.

• Added ExpressionBuilder#ternary.

• Added TypeDefBuilder.
• Added FunctionParameterBuilder.
• Added asAbstract to various MethodBuilder constructors.

• Re-published the package without merge conflicts.

• Renamed PartBuilder to PartOfBuilder.
• Added a new class, PartBuilder, to represent part '...dart' directives.
• Added the HasAnnotations interface to all library/part/directive builders.
• Added asFactory and asConst to ConstructorBuilder.
• Added ConstructorBuilder.redirectTo for a redirecting factory constructor.
• Added a name getter to ReferenceBuilder.
• Supplying an empty constructor name ('') is equivalent to null (default).
• Automatically encodes string literals with multiple lines as '''.
• Added asThrow to ExpressionBuilder.
• Fixed a bug that prevented FieldBuilder from being used at the top-level.

• Added support for genericTypes parameter for ExpressionBuilder#invoke:

expect(
  explicitThis.invoke('doThing', [literal(true)], genericTypes: [
    lib$core.bool,
  ]),
  equalsSource(r'''
    this.doThing<bool>(true)
  '''),
);

• Added a castAs method to ExpressionBuilder:

expect(
  literal(1.0).castAs(lib$core.num),
  equalsSource(r'''
    1.0 as num
  '''),
);

BREAKING CHANGES #

• Removed namedNewInstance and namedConstInstance, replaced with constructor: :

expect(
  reference('Foo').newInstance([], constructor: 'other'),
  equalsSource(r'''
    new Foo.other()
  '''),
);

• Renamed named parameter to namedArguments:

expect(
  reference('doThing').call(
    [literal(true)],
    namedArguments: {
      'otherFlag': literal(false),
    },
  ),
  equalsSource(r'''
    doThing(true, otherFlag: false)
  '''),
);

BREAKING CHANGES #

Avoid creating symbols that can collide with the Dart language:

• MethodModifier.async -> MethodModifier.asAsync
• MethodModifier.asyncStar -> MethodModifier.asAsyncStar
• MethodModifier.syncStar -> MethodModifier.asSyncStar

• Add support for switch statements
• Add support for a raw expression and statement
  • new ExpressionBuilder.raw(...)
  • new StatemnetBuilder.raw(...)

This should help cover any cases not covered with builders today.

• Allow referring to a ClassBuilder and TypeBuilder as an expression
• Add support for accessing the index [] operator on an expression

BREAKING CHANGES #

• Changed ExpressionBuilder.asAssign to always take an ExpressionBuilder as target and removed the value property. Most changes are pretty simple, and involve just using reference(...). For example:

literal(true).asAssign(reference('flag'))

... emits flag = true.

• Add support for async, sync, sync* functions
• Add support for expression asAwait, asYield, asYieldStar
• Add toExportBuilder and toImportBuilder to types and references
• Fix an import scoping bug in return statements and named constructor invocations.
• Added constructor initializer support
• Add while and do {} while loop support
• Add for and for-in support
• Added a name getter for ParameterBuilder

• Make use of new analyzer API in preparation for analyzer version 0.30.

• MethodBuilder.closure emits properly as a top-level function

• MethodBuilder with no statements will create an empty block instead of a semicolon.

// main() {}
method('main')

• Fix lambdas and closures to not include a trailing semicolon when used as an expression.

 // () => false
 new MethodBuilder.closure(returns: literal(false));

• Add support for latest pkg/analyzer.

• BREAKING CHANGE: Added generics support to TypeBuilder:

importFrom becomes a named, not positional argument, and the named argument genericTypes is added (Iterable<TypeBuilder>).

// List<String>
new TypeBuilder('List', genericTypes: [reference('String')])

• Added generic support to ReferenceBuilder:

// List<String>
reference('List').toTyped([reference('String')])

• Fixed a bug where ReferenceBuilder.buildAst was not implemented
• Added and and or methods to ExpressionBuilder:

// true || false
literal(true).or(literal(false));

// true && false
literal(true).and(literal(false));

• Added support for creating closures - MethodBuilder.closure:

// () => true
new MethodBuilder.closure(
  returns: literal(true),
  returnType: lib$core.bool,
)

• Added returnVoid to well, return;
• Added support for top-level field assignments:

new LibraryBuilder()..addMember(literal(false).asConst('foo'))

• Added support for specifying a target when using asAssign:

// Outputs bank.bar = goldBar
reference('goldBar').asAssign('bar', target: reference('bank'))

• Added support for the cascade operator:

// Outputs foo..doThis()..doThat()
reference('foo').cascade((c) => <ExpressionBuilder> [
  c.invoke('doThis', []),
  c.invoke('doThat', []),
]);

• Added support for accessing a property

// foo.bar
reference('foo').property('bar');

• Slight updates to confusing documentation.
• Added support for null-aware assignments.
• Added show and hide support to ImportBuilder
• Added deferred support to ImportBuilder
• Added ExportBuilder
• Added list and map literals that support generic types

• Large refactor that makes the library more feature complete.

• Add concept of Scope and change toAst to support it

Now your entire AST tree can be scoped and import directives automatically added to a LibraryBuilder for you if you use LibraryBuilder.scope.

• Initial version