Dart 2.0 Support

.gitignore

@@ -9,3 +9,4 @@ doc/gen
 doc/tutorial/bin/packages
 .idea/
 .packages
+.dart_tool

CHANGELOG.md

@@ -1,5 +1,12 @@
 # Parsers Changelog
 
+## 2.0.0
+
+- Dart 2.0 compatible
+- Operators disabled for now, so instead of `parser1 | parser2` use `parser1.or(parser2)`
+- `%` operator is an exception as it does not require any type parameters
+- Examples in `example` directory still don't work.
+
 ## 1.0.0
 
 - Make strong mode and dart 2 compatible.

analysis_options.yaml

@@ -1,2 +1,34 @@
 analyzer:
-  strong-mode: true
+  strong-mode:
+    implicit-casts: false
+    implicit-dynamic: true
+
+linter:
+  rules:
+    # - avoid_positional_boolean_parameters
+    - avoid_types_on_closure_parameters
+    - avoid_unused_constructor_parameters
+    - directives_ordering
+    - file_names
+    # - flutter_style_todos
+    - parameter_assignments
+    - prefer_adjacent_string_concatenation
+    - prefer_asserts_in_initializer_lists
+    - prefer_const_declarations
+    - prefer_final_fields
+    - prefer_final_locals
+    # - prefer_for_elements_to_map_fromIterable # not yet landed in stable
+    - prefer_generic_function_type_aliases
+    # - prefer_if_elements_to_conditional_expressions # not yet landed in stable
+    - prefer_is_empty
+    - prefer_single_quotes
+    # - prefer_spread_collections # not yet landed in stable
+    - prefer_typing_uninitialized_variables
+    - recursive_getters
+    - unnecessary_await_in_return
+    - unnecessary_lambdas
+    - unnecessary_const
+    - unnecessary_new
+    - use_function_type_syntax_for_parameters
+    - use_rethrow_when_possible
+    - use_to_and_as_if_applicable

example/full_arith.dart

@@ -1,7 +1,9 @@
 // Copyright (c) 2012, Google Inc. All rights reserved. Use of this source code
 // is governed by a BSD-style license that can be found in the LICENSE file.
 
-// Author: Paul Brauner ([email protected])
+// Authors:
+//   Paul Brauner ([email protected])
+//   Dinesh Ahuja ([email protected])
 
 library example;
 
@@ -10,35 +12,37 @@ import 'package:parsers/parsers.dart';
 // Same example as example.dart, with the additional use of chainl1 which
 // helps handling infix operators with the same precedence.
 
-class Arith {
+typedef MathFunction<T> = T Function(T a, T b);
 
-  digits2int(digits) => int.parse(digits.join());
+class Arith {
+  int digits2int(List<String> digits) => int.parse(digits.join());
 
-  lexeme(parser) => parser < spaces;
-  token(str)     => lexeme(string(str));
-  parens(parser) => parser.between(token('('), token(')'));
+  Parser<A> lexeme<A>(Parser<A> parser) => parser.thenDrop(spaces);
+  Parser<String> token(String str) => lexeme(string(str));
+  Parser<A> parens<A>(Parser<A> parser) =>
+      parser.between(token('('), token(')'));
 
-  get start => expr() < eof;
+  Parser<int> get start => expr().thenDrop(eof);
 
-  get comma  => token(',');
-  get times  => token('*');
-  get div    => token('~/');
-  get plus   => token('+');
-  get minus  => token('-');
-  get number => lexeme(digit.many1)  ^ digits2int;
+  Parser<String> get comma => token(',');
+  Parser<String> get times => token('*');
+  Parser<String> get div => token('~/');
+  Parser<String> get plus => token('+');
+  Parser<String> get minus => token('-');
+  Parser<int> get number => (lexeme(digit.many1).map(digits2int));
 
-  expr() => rec(term).chainl1(addop);
-  term() => rec(atom).chainl1(mulop);
-  atom() => number | parens(rec(expr));
+  Parser<int> expr() => rec(term).chainl1(addop);
+  Parser<int> term() => rec(atom).chainl1(mulop);
+  Parser<int> atom() => number.or(parens(rec(expr)));
 
-  get addop => (plus  > success((x, y) => x + y))
-             | (minus > success((x, y) => x - y));
+  Parser<MathFunction> get addop => (plus.thenKeep(success((x, y) => x + y)))
+      .or(minus.thenKeep(success((x, y) => x - y)));
 
-  get mulop => (times > success((x, y) => x * y))
-             | (div   > success((x, y) => x ~/ y));
+  Parser<MathFunction> get mulop => (times.thenKeep(success((x, y) => x * y)))
+      .or(div.thenKeep(success((x, y) => x ~/ y)));
 }
 
 main() {
-  final s = "1 * 2 ~/ 2 + 3 * (4 + 5 - 1)";
-  print(new Arith().start.parse(s)); // prints 25
+  const s = '1 * 2 ~/ 2 + 3 * (4 + 5 - 1)';
+  print(Arith().start.parse(s)); // prints 25
 }

example/mini_ast.dart

@@ -82,107 +82,101 @@ class FieldDeclaration {
 }
 
 NamespaceDeclaration namespaceDeclarationMapping(doc, _, name, body, __) =>
-  new NamespaceDeclaration(name, body, doc);
+    NamespaceDeclaration(name, body, doc);
 
 InterfaceDeclaration interfaceDeclarationMapping(doc, _, name, body, __) =>
-  new InterfaceDeclaration(name, body, doc);
+    InterfaceDeclaration(name, body, doc);
 
 MethodDeclaration methodDeclarationRegularMapping(
-    doc, returnType, name, parameters, _) =>
-  new MethodDeclaration(returnType, name, parameters, doc);
+        doc, returnType, name, parameters, _) =>
+    MethodDeclaration(returnType, name, parameters, doc);
 
 MethodDeclaration methodDeclarationReservedMapping(
-    doc, returnType, name, parameters, _) =>
-  new MethodDeclaration(new TypeAppl(returnType, null), name, parameters, doc);
+        doc, returnType, name, parameters, _) =>
+    MethodDeclaration(TypeAppl(returnType, null), name, parameters, doc);
 
-DictionaryDeclaration dictionaryDeclarationMapping(
-    doc, _, name, body, __) =>
-  new DictionaryDeclaration(name, body, doc);
+DictionaryDeclaration dictionaryDeclarationMapping(doc, _, name, body, __) =>
+    DictionaryDeclaration(name, body, doc);
 
 FieldDeclaration fieldDeclarationMapping(doc, type, name, _) =>
-  new FieldDeclaration(type, name, doc);
+    FieldDeclaration(type, name, doc);
 
 class DataCoreParser extends LanguageParsers {
-
-  DataCoreParser() : super(reservedNames: reservedNames,
-                           // tells LanguageParsers to not handle comments
-                           commentStart: "",
-                           commentEnd: "",
-                           commentLine: "");
+  DataCoreParser()
+      : super(
+            reservedNames: reservedNames,
+            // tells LanguageParsers to not handle comments
+            commentStart: "",
+            commentEnd: "",
+            commentLine: "");
 
   Parser get docString => lexeme(_docString).many;
 
   Parser get _docString =>
-        everythingBetween(string('//'), string('\n'))
-      | everythingBetween(string('/*'), string('*/'))
-      | everythingBetween(string('/**'), string('*/'));
+      everythingBetween(string('//'), string('\n')) |
+      everythingBetween(string('/*'), string('*/')) |
+      everythingBetween(string('/**'), string('*/'));
 
   Parser get namespaceDeclaration =>
-      docString
-      + reserved["namespace"]
-      + identifier
-      + braces(namespaceBody)
-      + semi
-      ^ namespaceDeclarationMapping;
+      docString +
+          reserved["namespace"] +
+          identifier +
+          braces(namespaceBody) +
+          semi ^
+      namespaceDeclarationMapping;
 
   Parser get namespaceBody => body.many;
 
   Parser get body => interfaceDeclaration | dictionaryDeclaration;
 
   Parser get interfaceDeclaration =>
-      docString
-      + reserved["interface"]
-      + identifier
-      + braces(interfaceBody)
-      + semi
-      ^ interfaceDeclarationMapping;
+      docString +
+          reserved["interface"] +
+          identifier +
+          braces(interfaceBody) +
+          semi ^
+      interfaceDeclarationMapping;
 
   Parser get interfaceBody => method.many;
 
   Parser get method => regularMethod | voidMethod;
 
   Parser typeAppl() =>
-      identifier
-      + angles(rec(typeAppl).sepBy(comma)).orElse([])
-      ^ (c, args) => new TypeAppl(c, args);
+      identifier + angles(rec(typeAppl).sepBy(comma)).orElse([]) ^
+      (c, args) => TypeAppl(c, args);
 
   Parser get parameter =>
-      (typeAppl() % 'type')
-      + (identifier % 'parameter')
-      ^ (t, p) => new Parameter(t, p);
+      (typeAppl() % 'type') + (identifier % 'parameter') ^
+      (t, p) => Parameter(t, p);
 
   Parser get regularMethod =>
-      docString
-      + typeAppl()
-      + identifier
-      + parens(parameter.sepBy(comma))
-      + semi
-      ^ methodDeclarationRegularMapping;
+      docString +
+          typeAppl() +
+          identifier +
+          parens(parameter.sepBy(comma)) +
+          semi ^
+      methodDeclarationRegularMapping;
 
   Parser get voidMethod =>
-      docString
-      + reserved['void']
-      + identifier
-      + parens(parameter.sepBy(comma))
-      + semi
-      ^ methodDeclarationReservedMapping;
+      docString +
+          reserved['void'] +
+          identifier +
+          parens(parameter.sepBy(comma)) +
+          semi ^
+      methodDeclarationReservedMapping;
 
   Parser get dictionaryDeclaration =>
-      docString
-      + reserved["dictionary"]
-      + identifier
-      + braces(dictionaryBody)
-      + semi
-      ^ dictionaryDeclarationMapping;
+      docString +
+          reserved["dictionary"] +
+          identifier +
+          braces(dictionaryBody) +
+          semi ^
+      dictionaryDeclarationMapping;
 
   Parser get dictionaryBody => field.many;
 
   Parser get field =>
-      docString
-      + typeAppl()
-      + identifier
-      + semi
-      ^ fieldDeclarationMapping;
+      docString + typeAppl() + identifier + semi ^ fieldDeclarationMapping;
 }
 
 final test = """
@@ -219,7 +213,7 @@ namespace datacore {
 """;
 
 void main() {
-  DataCoreParser dataCoreParser = new DataCoreParser();
+  DataCoreParser dataCoreParser = DataCoreParser();
   NamespaceDeclaration namespaceDeclaration =
       dataCoreParser.namespaceDeclaration.between(spaces, eof).parse(test);
   print(namespaceDeclaration);

example/mini_lang.dart

@@ -16,32 +16,32 @@ class MiniLang extends LanguageParsers {
   get start => stmts().between(spaces, eof);
 
   stmts() => stmt().endBy(semi);
-  stmt() => declStmt()
-          | assignStmt()
-          | ifStmt();
+  stmt() => declStmt() | assignStmt() | ifStmt();
   // In a real parser, we would build AST nodes, but here we turn sequences
   // into lists via the list getter for simplicity.
   declStmt() => (reserved['var'] + identifier + symbol('=') + expr()).list;
   assignStmt() => (identifier + symbol('=') + expr()).list;
-  ifStmt() => (reserved['if']
-               + parens(expr())
-               + braces(rec(stmts))
-               + reserved['else']
-               + braces(rec(stmts))).list;
+  ifStmt() => (reserved['if'] +
+          parens(expr()) +
+          braces(rec(stmts)) +
+          reserved['else'] +
+          braces(rec(stmts)))
+      .list;
 
   expr() => disj().sepBy1(symbol('||'));
   disj() => comp().sepBy1(symbol('&&'));
   comp() => arith().sepBy1(symbol('<') | symbol('>'));
   arith() => term().sepBy1(symbol('+') | symbol('-'));
   term() => atom().withPosition.sepBy1(symbol('*') | symbol('/'));
 
-  atom() => floatLiteral
-          | intLiteral
-          | stringLiteral
-          | reserved['true']
-          | reserved['false']
-          | identifier
-          | parens(rec(expr));
+  atom() =>
+      floatLiteral |
+      intLiteral |
+      stringLiteral |
+      reserved['true'] |
+      reserved['false'] |
+      identifier |
+      parens(rec(expr));
 }
 
 final test = """
@@ -59,5 +59,5 @@ final test = """
 """;
 
 main() {
-  print(new MiniLang().start.parse(test));
+  print(MiniLang().start.parse(test));
 }