Beta release fixes and feature. (#149)

* Beta release fixes and feature.

* Dartfmt.

Author: matanlurey

CHANGELOG.md

@@ -1,3 +1,10 @@
+## 2.0.0-beta
+
+* Added `lazySpec` and `lazyCode` to lazily create code on visit [#145](https://github.com/dart-lang/code_builder/issues/145).
+
+* **BUG FIX**: `equalsDart` emits the failing source code [#147](https://github.com/dart-lang/code_builder/issues/147).
+* **BUG FIX**: Top-level `lambda` `Method`s no longer emit invalid code [#146](https://github.com/dart-lang/code_builder/issues/146).
+
 ## 2.0.0-alpha+3
 
 * Added `Expression.annotation` and `Expression.annotationNamed`.

lib/code_builder.dart

@@ -3,13 +3,13 @@
 // BSD-style license that can be found in the LICENSE file.
 
 export 'src/allocator.dart' show Allocator;
-export 'src/base.dart' show Spec;
+export 'src/base.dart' show lazySpec, Spec;
 export 'src/emitter.dart' show DartEmitter;
 export 'src/matchers.dart' show equalsDart;
 export 'src/specs/annotation.dart' show Annotation, AnnotationBuilder;
 export 'src/specs/class.dart' show Class, ClassBuilder;
 export 'src/specs/code.dart'
-    show Block, BlockBuilder, Code, StaticCode, ScopedCode;
+    show lazyCode, Block, BlockBuilder, Code, StaticCode, ScopedCode;
 export 'src/specs/constructor.dart' show Constructor, ConstructorBuilder;
 export 'src/specs/directive.dart'
     show Directive, DirectiveType, DirectiveBuilder;

lib/src/allocator.dart

@@ -2,6 +2,8 @@
 // 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:path/path.dart' as p;
+
 import 'specs/directive.dart';
 import 'specs/reference.dart';
 

lib/src/base.dart

@@ -7,3 +7,17 @@ import 'visitors.dart';
 abstract class Spec {
   R accept<R>(SpecVisitor<R> visitor, [R context]);
 }
+
+/// Returns a generic [Spec] that is lazily generated when visited.
+Spec lazySpec(Spec Function() generate) => new _LazySpec(generate);
+
+class _LazySpec implements Spec {
+  final Spec Function() generate;
+
+  const _LazySpec(this.generate);
+
+  @override
+  R accept<R>(SpecVisitor<R> visitor, [R context]) {
+    return generate().accept(visitor, context);
+  }
+}

lib/src/emitter.dart

@@ -271,7 +271,7 @@ class DartEmitter extends Object
     for (final spec in spec.body) {
       body.write(visitSpec(spec));
       if (spec is Method && spec.lambda) {
-        output.write(';');
+        body.write(';');
       }
     }
     // TODO: Allow some sort of logical ordering.

lib/src/matchers.dart

@@ -18,7 +18,6 @@ String _dartfmt(String source) {
     source = _formatter.formatStatement(source);
   } catch (_) {
     // Ignored on purpose, probably not exactly valid Dart code.
-  } finally {
     source = collapseWhitespace(source);
   }
   return source;
@@ -54,7 +53,7 @@ class _EqualsDart extends Matcher {
     final result = _dart(item, _emitter);
     return equals(result).describeMismatch(
       _source,
-      mismatchDescription,
+      mismatchDescription.add(result),
       state,
       verbose,
     );

lib/src/specs/code.dart

@@ -51,6 +51,10 @@ abstract class Code implements Spec {
 abstract class Block implements Built<Block, BlockBuilder>, Code, Spec {
   factory Block([void updates(BlockBuilder b)]) = _$Block;
 
+  factory Block.of(Iterable<Code> statements) {
+    return new Block((b) => b..statements.addAll(statements));
+  }
+
   Block._();
 
   @override
@@ -111,7 +115,33 @@ abstract class CodeEmitter implements CodeVisitor<StringSink> {
   }
 }
 
-/// Represents a simple, literal [code] block to be inserted as-is.
+/// Represents a code block that requires lazy visiting.
+class LazyCode implements Code {
+  final Spec Function(SpecVisitor) generate;
+
+  const LazyCode._(this.generate);
+
+  @override
+  R accept<R>(CodeVisitor<R> visitor, [R context]) {
+    return generate(visitor).accept(visitor, context);
+  }
+}
+
+/// Returns a generic [Code] that is lazily generated when visited.
+Code lazyCode(Code Function() generate) => new _LazyCode(generate);
+
+class _LazyCode implements Code {
+  final Code Function() generate;
+
+  const _LazyCode(this.generate);
+
+  @override
+  R accept<R>(CodeVisitor<R> visitor, [R context]) {
+    return generate().accept(visitor, context);
+  }
+}
+
+/// Represents a simple, literal code block to be inserted as-is.
 class StaticCode implements Code {
   final String code;
 
@@ -126,9 +156,9 @@ class StaticCode implements Code {
   String toString() => code;
 }
 
-/// Represents a [code] block that may require scoping.
+/// Represents a code block that may require scoping.
 class ScopedCode implements Code {
-  final String Function(Allocate allocate) code;
+  final String Function(Allocate) code;
 
   const ScopedCode._(this.code);
 

pubspec.yaml

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

test/specs/code/statement_test.dart

@@ -8,11 +8,11 @@ import 'package:test/test.dart';
 void main() {
   test('should emit a block of code', () {
     expect(
-      new Block((b) => b.statements.addAll([
-            const Code('if (foo) {'),
-            const Code('  print(true);'),
-            const Code('}'),
-          ])),
+      new Block.of([
+        const Code('if (foo) {'),
+        const Code('  print(true);'),
+        const Code('}'),
+      ]),
       equalsDart(r'''
         if (foo) {
           print(true);
@@ -23,16 +23,37 @@ void main() {
 
   test('should emit a block of code including expressions', () {
     expect(
-      new Block((b) => b.statements.addAll([
-            const Code('if (foo) {'),
-            refer('print')([literalTrue]).statement,
-            const Code('}'),
-          ])),
+      new Block.of([
+        const Code('if (foo) {'),
+        refer('print')([literalTrue]).statement,
+        const Code('}'),
+      ]),
       equalsDart(r'''
         if (foo) {
           print(true);
         }
       '''),
     );
   });
+
+  test('should emit a block of code with lazyily invoked generators', () {
+    expect(
+      new Method((b) => b
+        ..name = 'main'
+        ..body = new Block.of([
+          const Code('if ('),
+          lazyCode(() => refer('foo').code),
+          const Code(') {'),
+          refer('print')([literalTrue]).statement,
+          const Code('}'),
+        ])),
+      equalsDart(r'''
+        main() {
+          if (foo) {
+            print(true);
+          }
+        }
+      '''),
+    );
+  });
 }