werediver / dart-reptr-rs Goto Github PK

The goal is to identify Dart source files which were parsed without a failure before, but cannot be parsed after certain changes.

To achieve that:

• Log both the successful and failed parses
• Match the set of files parsed successfully during a run against a "reference" set
  • Report regressions (was parsed, not failed)
  • Report improvements (was failed, now parsed)
  • Distinguish regressions and improvements from results for new or deleted files

Please create and link 🎟️ tickets for individual items.

• Comment (ref.)
  • Single line (including doc-comment)
  • Multi-line
    • #18
• Directives
  • Import
    • Simple import
      • #8
    • deferred: (deferred? as <typeIdentifier>)?
    • Qualified (as)
    • Selective (show, hide)
  • part and part of
  • export
    • Selective (show, hide)
• String
  • Simple single- and double-quoted (e.g. as in import statement)
    • #8
  • Variations
    • 'x', "x" (line breaks not allowed)
    • '''x''', """x""" (the line break right after the opening quotes is ignored)
    • r'x', r"x", r"""x""" (raw, no escape sequences or interpolation)
    • A newline starting a multiline string is ignored
  • Escape sequences
  • (Skip) Interpolation
  • (Unimportant?) Adjacent literals (ref.)
• Type alias (ref.)
  • #43
• Types
  • Simple types (e.g. Object, Map<String, Object?>)
  • Function type
    • #37
    • Generic function type (T Function<T>(T))
  • Tuple type
    • Tuples with named fields
• (Skip) Special constructors for List (<·>[]), Set (<·>{}), Map (<·, ·>{})
• Identifier
• Generics (ref.)
  • Type parameters with constraints (extends)
    • #34
  • Type arguments (with nested parametrized types)
    • #15
• Top-level variable
• Top-level function (skip the implementation)
• Class
  • Class modifiers (final, sealed, etc.)
  • extends clause
    • #10
  • implements clause
    • #12
  • Constructor (ref.)
    • Unnamed
    • Named
    • (Skip) Initializer list, assertions, delegation / redirection
  • Method (ref.)
    • Always skip the implementation
    • Getter (abstract and with implementation)
    • Setter (abstract and with implementation)
    • Instance method (abstract and with implementation)
    • Operator (ref.)
      • #44
  • Stored property (instance variable)
    • #14
• Enum
  • Enhanced enum
• Extension
• Annotation (ref.)
  • #40
  • Class annotation (e.g. @immutable, @JsonSerializable(fieldRename: FieldRename.snake), etc.)
  • Class member annotation
  • Top-level function, variable annotation
  • Function parameter annotation

References

• A formal (but incomplete) Dart language specification: https://dart.dev/guides/language/spec
• Analyzer / AST library: https://pub.dev/documentation/analyzer/latest/dart_ast_ast/dart_ast_ast-library.html

Parse type parameters, with constraints.

Examples:

• Type parameters of a generic class

class Log<T extends Object> {}
//       ^^^^^^^^^^^^^^^^^^

• Type parameters of a generic function

U? nmap<T, U>(T? o, U Function(T) f) => o != null ? f(o) : null;
//     ^^^^^^

Reference

• Generics in Dart language reference

Note that in Dart multi-line comments allow nesting (/* x /* x */ x */).

Parse function types (e.g. void Function() Function()) in various positions. See identifier_ext().

P.S. Don't fall into left recursion.

Create a custom (hand-coded) parser using nom.

• Skip over whitespace and comments
• Parse a very basic subset of the class declaration syntax

// A comment
class Record {
  int field;
}

The base-line implementation. Compare to #5.

Find Dart files in Dart packages (check for pubspec.yaml + lib/ or bin/).

Different approaches to loading files: #4, #5.

Allow accurate back-to-source transformation to enable in-place code generation and code transformation.

Parse typedef type aliases (ref.).

Some examples:

typedef JsonObject = Map<String, Object?>;
typedef Many<T extends Object> = List<T>;

From Intro to Dart, Metadata:

Metadata can appear before a library, class, typedef, type parameter, constructor, factory, function, field, parameter, or variable declaration and before an import or export directive.

From Dart lang spec, Metadata:

It is a compile-time error if [the annotation expression] e is not one of the following:

• A reference to a constant variable.
• A call to a constant constructor.

The expression e occurs in a constant context (17.3.2), which means that const modifiers need not be specified explicitly.

See Methods / Operators.

Implement a Dart parser based on the ANTLR4 grammar https://github.com/dart-lang/sdk/blob/main/tools/spec_parser/Dart.g in Rust.

See #61 for details.

Parse identifiers with type arguments (with nested identifiers with type arguments).