Fix a number of issues. (#140)

* Fix a number of issues.

* OK, add some tests.

* Dartfmt.

Author: matanlurey

CHANGELOG.md

@@ -1,3 +1,12 @@
+## 2.0.0-alpha+3
+
+* Added `{new|const}InstanceNamed` to `Expression` [#135](https://github.com/dart-lang/code_builder/issues/135).
+  * Also added a `typeArguments` option to all invocations.
+* **BUG FIX**: `Block` now implements `Code` [#136](https://github.com/dart-lang/code_builder/issues/136).
+* Added `assign{...}` variants to `Expression` [#137](https://github.com/dart-lang/code_builder/issues/137).
+* Added `.awaited` and `.returned` to `Expression` [#138](https://github.com/dart-lang/code_builder/issues/138).
+* **BUG FIX**: `new DartEmitter.scoped()` applies prefixing [#139](https://github.com/dart-lang/code_builder/issues/139).
+
 ## 2.0.0-alpha+2
 
 * Upgraded `build_runner` from `^0.3.0` to `>=0.4.0 <0.6.0`.

lib/src/emitter.dart

@@ -58,8 +58,10 @@ class DartEmitter extends Object
   /// May specify an [Allocator] to use for symbols, otherwise uses a no-op.
   DartEmitter([this.allocator = Allocator.none]);
 
-  /// Creates a new instance of [DartEmitter] with a default [Allocator].
-  factory DartEmitter.scoped() => new DartEmitter(new Allocator());
+  /// Creates a new instance of [DartEmitter] with simple automatic imports.
+  factory DartEmitter.scoped() {
+    return new DartEmitter(new Allocator.simplePrefixing());
+  }
 
   @override
   visitAnnotation(Annotation spec, [StringSink output]) {

lib/src/specs/code.dart

@@ -48,7 +48,7 @@ abstract class Code implements Spec {
 }
 
 /// Represents blocks of statements of Dart code.
-abstract class Block implements Built<Block, BlockBuilder>, Spec {
+abstract class Block implements Built<Block, BlockBuilder>, Code, Spec {
   factory Block([void updates(BlockBuilder b)]) = _$Block;
 
   Block._();

lib/src/specs/expression.dart

@@ -39,15 +39,89 @@ abstract class Expression implements Spec {
     return new BinaryExpression._(toExpression(), other, '&&');
   }
 
+  /// This expression preceding by `await`.
+  Expression get awaited {
+    return new BinaryExpression._(
+      const LiteralExpression._('await'),
+      this,
+      '',
+    );
+  }
+
+  /// Return `{other} = {this}`.
+  Expression assign(Expression other) {
+    return new BinaryExpression._(
+      other,
+      this,
+      '=',
+    );
+  }
+
+  /// Return `{other} ??= {this}`.
+  Expression assignNullAware(Expression other) {
+    return new BinaryExpression._(
+      other,
+      this,
+      '??=',
+    );
+  }
+
+  /// Return `var {name} = {this}`.
+  Expression assignVar(String name, [Reference type]) {
+    return new BinaryExpression._(
+      type == null
+          ? new LiteralExpression._('var $name')
+          : new BinaryExpression._(
+              type.toExpression(),
+              new LiteralExpression._(name),
+              '',
+            ),
+      this,
+      '=',
+    );
+  }
+
+  /// Return `final {name} = {this}`.
+  Expression assignFinal(String name, [Reference type]) {
+    return new BinaryExpression._(
+      type == null
+          ? const LiteralExpression._('final')
+          : new BinaryExpression._(
+              const LiteralExpression._('final'),
+              type.toExpression(),
+              '',
+            ),
+      this,
+      '$name =',
+    );
+  }
+
+  /// Return `const {name} = {this}`.
+  Expression assignConst(String name, [Reference type]) {
+    return new BinaryExpression._(
+      type == null
+          ? const LiteralExpression._('const')
+          : new BinaryExpression._(
+              const LiteralExpression._('const'),
+              type.toExpression(),
+              '',
+            ),
+      this,
+      '$name =',
+    );
+  }
+
   /// Call this expression as a method.
   Expression call(
     List<Expression> positionalArguments, [
     Map<String, Expression> namedArguments = const {},
+    List<Reference> typeArguments = const [],
   ]) {
     return new InvokeExpression._(
       this,
       positionalArguments,
       namedArguments,
+      typeArguments,
     );
   }
 
@@ -65,27 +139,74 @@ abstract class Expression implements Spec {
   Expression newInstance(
     List<Expression> positionalArguments, [
     Map<String, Expression> namedArguments = const {},
+    List<Reference> typeArguments = const [],
   ]) {
     return new InvokeExpression._new(
       this,
       positionalArguments,
       namedArguments,
+      typeArguments,
+      null,
+    );
+  }
+
+  /// Returns a new instance of this expression with a named constructor.
+  Expression newInstanceNamed(
+    String name,
+    List<Expression> positionalArguments, [
+    Map<String, Expression> namedArguments = const {},
+    List<Reference> typeArguments = const [],
+  ]) {
+    return new InvokeExpression._new(
+      this,
+      positionalArguments,
+      namedArguments,
+      typeArguments,
+      name,
     );
   }
 
   /// Returns a const instance of this expression.
   Expression constInstance(
     List<Expression> positionalArguments, [
     Map<String, Expression> namedArguments = const {},
+    List<Reference> typeArguments = const [],
   ]) {
     return new InvokeExpression._const(
       this,
       positionalArguments,
       namedArguments,
+      typeArguments,
+      null,
     );
   }
 
-  /// May be overriden to support other types implementing [Expression].
+  /// Returns a const instance of this expression with a named constructor.
+  Expression constInstanceNamed(
+    String name,
+    List<Expression> positionalArguments, [
+    Map<String, Expression> namedArguments = const {},
+    List<Reference> typeArguments = const [],
+  ]) {
+    return new InvokeExpression._const(
+      this,
+      positionalArguments,
+      namedArguments,
+      typeArguments,
+      name,
+    );
+  }
+
+  /// This expression preceding by `return`.
+  Expression get returned {
+    return new BinaryExpression._(
+      const LiteralExpression._('return'),
+      this,
+      '',
+    );
+  }
+
+  /// May be overridden to support other types implementing [Expression].
   @visibleForOverriding
   Expression toExpression() => this;
 }
@@ -171,6 +292,16 @@ abstract class ExpressionEmitter implements ExpressionVisitor<StringSink> {
         break;
     }
     expression.target.accept(this, output);
+    if (expression.name != null) {
+      output..write('.')..write(expression.name);
+    }
+    if (expression.typeArguments.isNotEmpty) {
+      output.write('<');
+      visitAll<Reference>(expression.typeArguments, output, (type) {
+        type.accept(this, output);
+      });
+      output.write('>');
+    }
     output.write('(');
     visitAll<Spec>(expression.positionalArguments, output, (spec) {
       spec.accept(this, output);

lib/src/specs/expression/invoke.dart

@@ -13,27 +13,34 @@ class InvokeExpression extends Expression {
   final InvokeExpressionType type;
 
   final List<Expression> positionalArguments;
-
   final Map<String, Expression> namedArguments;
+  final List<Reference> typeArguments;
+  final String name;
 
   const InvokeExpression._(
     this.target,
     this.positionalArguments, [
     this.namedArguments = const {},
+    this.typeArguments,
   ])
-      : type = null;
+      : type = null,
+        name = null;
 
   const InvokeExpression._new(
     this.target,
     this.positionalArguments, [
     this.namedArguments = const {},
+    this.typeArguments,
+    this.name,
   ])
       : type = InvokeExpressionType.newInstance;
 
   const InvokeExpression._const(
     this.target,
     this.positionalArguments, [
     this.namedArguments = const {},
+    this.typeArguments,
+    this.name,
   ])
       : type = InvokeExpressionType.constInstance;
 

pubspec.yaml

@@ -1,5 +1,5 @@
 name: code_builder
-version: 2.0.0-alpha+2
+version: 2.0.0-alpha+3
 description: A fluent API for generating Dart code
 author: Dart Team <[email protected]>
 homepage: https://github.com/dart-lang/code_builder

test/specs/code/expression_test.dart

@@ -78,6 +78,20 @@ void main() {
     );
   });
 
+  test('should emit invoking new named constructor', () {
+    expect(
+      refer('Foo').newInstanceNamed('bar', []),
+      equalsDart('new Foo.bar()'),
+    );
+  });
+
+  test('should emit invoking const Type()', () {
+    expect(
+      refer('Object').constInstance([]),
+      equalsDart('const Object()'),
+    );
+  });
+
   test('should emit invoking a property accessor', () {
     expect(refer('foo').property('bar'), equalsDart('foo.bar'));
   });
@@ -132,4 +146,80 @@ void main() {
       equalsDart('foo(1, bar: 2, baz: 3)'),
     );
   });
+
+  test('should emit invoking a method with a single type argument', () {
+    expect(
+      refer('foo').call(
+        [],
+        {},
+        [
+          refer('String'),
+        ],
+      ),
+      equalsDart('foo<String>()'),
+    );
+  });
+
+  test('should emit invoking a method with type arguments', () {
+    expect(
+      refer('foo').call(
+        [],
+        {},
+        [
+          refer('String'),
+          refer('int'),
+        ],
+      ),
+      equalsDart('foo<String, int>()'),
+    );
+  });
+
+  test('should emit an assignment', () {
+    expect(
+      literalTrue.assign(refer('foo')),
+      equalsDart('foo = true'),
+    );
+  });
+
+  test('should emit assigning to a var', () {
+    expect(
+      literalTrue.assignVar('foo'),
+      equalsDart('var foo = true'),
+    );
+  });
+
+  test('should emit assigning to a type', () {
+    expect(
+      literalTrue.assignVar('foo', refer('bool')),
+      equalsDart('bool foo = true'),
+    );
+  });
+
+  test('should emit assigning to a final', () {
+    expect(
+      literalTrue.assignFinal('foo'),
+      equalsDart('final foo = true'),
+    );
+  });
+
+  test('should emit assigning to a const', () {
+    expect(
+      literalTrue.assignConst('foo'),
+      equalsDart('const foo = true'),
+    );
+  });
+
+  test('should emit await', () {
+    expect(
+      refer('future').awaited,
+      equalsDart('await future'),
+    );
+  });
+
+  test('should emit return', () {
+    expect(
+      literalNull.returned,
+      equalsDart('return null'),
+    );
+  });
 }

test/specs/file_test.dart

@@ -88,7 +88,7 @@ void main() {
           import 'dart:collection';
           
           final test = new LinkedHashMap();
-        ''', new DartEmitter.scoped()),
+        ''', new DartEmitter(new Allocator())),
       );
     });