@cparra/apex-reflection 0.1.0-alpha.0 → 0.1.1-alpha.10

package/antlr4-4.9.2/lib/src/tree/src/tree.dart

@@ -1,370 +0,0 @@
-/*
- * Copyright (c) 2012-2017 The ANTLR Project. All rights reserved.
- * Use of this file is governed by the BSD 3-clause license that
- * can be found in the LICENSE.txt file in the project root.
- */
-
-import 'dart:developer';
-
-import '../../interval_set.dart';
-import '../../parser.dart';
-import '../../parser_rule_context.dart';
-import '../../rule_context.dart';
-import '../../token.dart';
-
-/// The basic notion of a tree has a parent, a payload, and a list of children.
-///  It is the most abstract interface for all the trees used by ANTLR.
-abstract class Tree {
-  Tree get parent;
-
-  dynamic get payload;
-
-  Tree getChild<T>(int i);
-
-//  Tree getChild(int i);
-
-  int get childCount;
-
-  String toStringTree();
-}
-
-abstract class SyntaxTree extends Tree {
-  /// Return an [Interval] indicating the index in the
-  /// [TokenStream] of the first and last token associated with this
-  /// subtree. If this node is a leaf, then the interval represents a single
-  /// token and has interval i..i for token index i.
-  ///
-  /// <p>An interval of i..i-1 indicates an empty interval at position
-  /// i in the input stream, where 0 &lt;= i &lt;= the size of the input
-  /// token stream.  Currently, the code base can only have i=0..n-1 but
-  /// in concept one could have an empty interval after EOF. </p>
-  ///
-  /// <p>If source interval is unknown, this returns {@link Interval#INVALID}.</p>
-  ///
-  /// <p>As a weird special case, the source interval for rules matched after
-  /// EOF is unspecified.</p>
-  Interval get sourceInterval;
-}
-
-abstract class ParseTree extends SyntaxTree {
-  // the following methods narrow the return type; they are not additional methods
-  @override
-  ParseTree get parent;
-
-  @override
-  ParseTree getChild<T>(int i);
-
-  /// Set the parent for this node.
-  ///
-  ///  This is not backward compatible as it changes
-  ///  the interface but no one was able to create custom
-  ///  nodes anyway so I'm adding as it improves internal
-  ///  code quality.
-  ///
-  ///  One could argue for a restructuring of
-  ///  the class/interface hierarchy so that
-  ///  setParent, addChild are moved up to Tree
-  ///  but that's a major change. So I'll do the
-  ///  minimal change, which is to add this method.
-  ///
-  ///  @since 4.7
-  set parent(RuleContext parent);
-
-  /// The [ParseTreeVisitor] needs a double dispatch method. */
-  T accept<T>(ParseTreeVisitor<T> visitor);
-
-  /// Return the combined text of all leaf nodes. Does not get any
-  ///  off-channel tokens (if any) so won't return whitespace and
-  ///  comments if they are sent to parser on hidden channel.
-  String get text;
-
-  /// Specialize toStringTree so that it can print out more information
-  /// 	based upon the parser.
-  @override
-  String toStringTree({Parser parser});
-}
-
-abstract class RuleNode extends ParseTree {
-  RuleContext get ruleContext;
-}
-
-abstract class TerminalNode extends ParseTree {
-  Token get symbol;
-}
-
-abstract class ErrorNode extends TerminalNode {}
-
-abstract class ParseTreeVisitor<T> {
-  /// {@inheritDoc}
-  ///
-  /// <p>The default implementation calls {@link ParseTree#accept} on the
-  /// specified tree.</p>
-  T visit(ParseTree tree) {
-    return tree.accept(this);
-  }
-
-  /// {@inheritDoc}
-  ///
-  /// <p>The default implementation initializes the aggregate result to
-  /// {@link #defaultResult defaultResult()}. Before visiting each child, it
-  /// calls {@link #shouldVisitNextChild shouldVisitNextChild}; if the result
-  /// is [false] no more children are visited and the current aggregate
-  /// result is returned. After visiting a child, the aggregate result is
-  /// updated by calling {@link #aggregateResult aggregateResult} with the
-  /// previous aggregate result and the result of visiting the child.</p>
-  ///
-  /// <p>The default implementation is not safe for use in visitors that modify
-  /// the tree structure. Visitors that modify the tree should override this
-  /// method to behave properly in respect to the specific algorithm in use.</p>
-  T visitChildren(RuleNode node) {
-    var result = defaultResult();
-    final n = node.childCount;
-    for (var i = 0; i < n; i++) {
-      if (!shouldVisitNextChild(node, result)) {
-        break;
-      }
-
-      final c = node.getChild(i);
-      final childResult = c.accept(this);
-      result = aggregateResult(result, childResult);
-    }
-
-    return result;
-  }
-
-  /// {@inheritDoc}
-  ///
-  /// <p>The default implementation returns the result of
-  /// {@link #defaultResult defaultResult}.</p>
-
-  T visitTerminal(TerminalNode node) {
-    return defaultResult();
-  }
-
-  /// {@inheritDoc}
-  ///
-  /// <p>The default implementation returns the result of
-  /// {@link #defaultResult defaultResult}.</p>
-
-  T visitErrorNode(ErrorNode node) {
-    return defaultResult();
-  }
-
-  /// Gets the default value returned by visitor methods. This value is
-  /// returned by the default implementations of
-  /// {@link #visitTerminal visitTerminal}, {@link #visitErrorNode visitErrorNode}.
-  /// The default implementation of {@link #visitChildren visitChildren}
-  /// initializes its aggregate result to this value.
-  ///
-  /// <p>The base implementation returns null.</p>
-  ///
-  /// @return The default value returned by visitor methods.
-  T defaultResult() {
-    return null;
-  }
-
-  /// Aggregates the results of visiting multiple children of a node. After
-  /// either all children are visited or {@link #shouldVisitNextChild} returns
-  /// [false], the aggregate value is returned as the result of
-  /// {@link #visitChildren}.
-  ///
-  /// <p>The default implementation returns [nextResult], meaning
-  /// {@link #visitChildren} will return the result of the last child visited
-  /// (or return the initial value if the node has no children).</p>
-  ///
-  /// @param aggregate The previous aggregate value. In the default
-  /// implementation, the aggregate value is initialized to
-  /// {@link #defaultResult}, which is passed as the [aggregate] argument
-  /// to this method after the first child node is visited.
-  /// @param nextResult The result of the immediately preceeding call to visit
-  /// a child node.
-  ///
-  /// @return The updated aggregate result.
-  T aggregateResult(T aggregate, T nextResult) => nextResult;
-
-  /// This method is called after visiting each child in
-  /// {@link #visitChildren}. This method is first called before the first
-  /// child is visited; at that point [currentResult] will be the initial
-  /// value (in the default implementation, the initial value is returned by a
-  /// call to {@link #defaultResult}. This method is not called after the last
-  /// child is visited.
-  ///
-  /// <p>The default implementation always returns [true], indicating that
-  /// [visitChildren] should only return after all children are visited.
-  /// One reason to override this method is to provide a "short circuit"
-  /// evaluation option for situations where the result of visiting a single
-  /// child has the potential to determine the result of the visit operation as
-  /// a whole.</p>
-  ///
-  /// @param node The [RuleNode] whose children are currently being
-  /// visited.
-  /// @param currentResult The current aggregate result of the children visited
-  /// to the current point.
-  ///
-  /// @return [true] to continue visiting children. Otherwise return
-  /// [false] to stop visiting children and immediately return the
-  /// current aggregate result from {@link #visitChildren}.
-  bool shouldVisitNextChild(RuleNode node, T currentResult) => true;
-}
-
-abstract class ParseTreeListener {
-  void visitTerminal(TerminalNode node);
-
-  void visitErrorNode(ErrorNode node);
-
-  void enterEveryRule(ParserRuleContext node);
-
-  void exitEveryRule(ParserRuleContext node);
-}
-
-class TraceListener implements ParseTreeListener {
-  final Parser parser;
-
-  TraceListener(this.parser);
-
-  @override
-  void enterEveryRule(ParserRuleContext ctx) {
-    log('enter   ' +
-        parser.ruleNames[ctx.ruleIndex] +
-        ', LT(1)=${parser.inputStream.LT(1).text}');
-  }
-
-  @override
-  void visitTerminal(TerminalNode node) {
-    log('consume ${node.symbol} rule ' +
-        parser.ruleNames[parser.context.ruleIndex]);
-  }
-
-  @override
-  void visitErrorNode(ErrorNode node) {}
-
-  @override
-  void exitEveryRule(ParserRuleContext ctx) {
-    log('exit    ${parser.ruleNames[ctx.ruleIndex]}' ', LT(1)=' +
-        parser.inputStream.LT(1).text);
-  }
-}
-
-class TrimToSizeListener implements ParseTreeListener {
-  static final TrimToSizeListener INSTANCE = TrimToSizeListener();
-
-  @override
-  void enterEveryRule(ParserRuleContext ctx) {}
-
-  @override
-  void visitTerminal(TerminalNode node) {}
-
-  @override
-  void visitErrorNode(ErrorNode node) {}
-
-  @override
-  void exitEveryRule(ParserRuleContext ctx) {
-    // TODO trim dart List's size
-//    if (ctx.children is List) {
-//      (ctx.children).trimToSize();
-//    }
-  }
-}
-
-class TerminalNodeImpl extends TerminalNode {
-  @override
-  Token symbol;
-  @override
-  ParseTree parent;
-
-  TerminalNodeImpl(this.symbol);
-
-  @override
-  ParseTree getChild<T>(i) {
-    return null;
-  }
-
-  @override
-  Token get payload => symbol;
-
-  @override
-  Interval get sourceInterval {
-    if (symbol == null) return Interval.INVALID;
-
-    final tokenIndex = symbol.tokenIndex;
-    return Interval(tokenIndex, tokenIndex);
-  }
-
-  @override
-  int get childCount {
-    return 0;
-  }
-
-  @override
-  T accept<T>(ParseTreeVisitor<T> visitor) {
-    return visitor.visitTerminal(this);
-  }
-
-  @override
-  String get text {
-    return symbol.text;
-  }
-
-  @override
-  String toStringTree({Parser parser}) {
-    return toString();
-  }
-
-  @override
-  String toString() {
-    if (symbol.type == Token.EOF) return '<EOF>';
-    return symbol.text;
-  }
-}
-
-/// Represents a token that was consumed during resynchronization
-/// rather than during a valid match operation. For example,
-/// we will create this kind of a node during single token insertion
-/// and deletion as well as during "consume until error recovery set"
-/// upon no viable alternative exceptions.
-class ErrorNodeImpl extends TerminalNodeImpl implements ErrorNode {
-  ErrorNodeImpl(token) : super(token);
-
-  bool isErrorNode() => true;
-
-  @override
-  T accept<T>(ParseTreeVisitor<T> visitor) {
-    return visitor.visitErrorNode(this);
-  }
-}
-
-class ParseTreeWalker {
-  void walk(ParseTreeListener listener, ParseTree t) {
-    if (t is ErrorNode) {
-      listener.visitErrorNode(t);
-      return;
-    } else if (t is TerminalNode) {
-      listener.visitTerminal(t);
-      return;
-    }
-    RuleNode r = t;
-    enterRule(listener, r);
-    for (var i = 0; i < r.childCount; i++) {
-      walk(listener, r.getChild(i));
-    }
-    exitRule(listener, r);
-  }
-
-  /// The discovery of a rule node, involves sending two events: the generic
-  /// {@link ParseTreeListener#enterEveryRule} and a
-  /// [RuleContext]-specific event. First we trigger the generic and then
-  /// the rule specific. We to them in reverse order upon finishing the node.
-  void enterRule(ParseTreeListener listener, RuleNode r) {
-    ParserRuleContext ctx = r.ruleContext;
-    listener.enterEveryRule(ctx);
-    ctx.enterRule(listener);
-  }
-
-  void exitRule(ParseTreeListener listener, RuleNode r) {
-    ParserRuleContext ctx = r.ruleContext;
-    ctx.exitRule(listener);
-    listener.exitEveryRule(ctx);
-  }
-
-  static final DEFAULT = ParseTreeWalker();
-}

package/antlr4-4.9.2/lib/src/tree/src/trees.dart

@@ -1,226 +0,0 @@
-/*
- * Copyright (c) 2012-2017 The ANTLR Project. All rights reserved.
- * Use of this file is governed by the BSD 3-clause license that
- * can be found in the LICENSE.txt file in the project root.
- */
-
-import 'dart:core';
-
-import '../../atn/atn.dart';
-import '../../parser.dart';
-import '../../parser_rule_context.dart';
-import '../../rule_context.dart';
-import '../../token.dart';
-import '../../util/utils.dart';
-import 'tree.dart';
-
-/// A set of utility routines useful for all kinds of ANTLR trees. */
-class Trees {
-  /// Print out a whole tree in LISP form. {@link #getNodeText} is used on the
-  ///  node payloads to get the text for the nodes.  Detect
-  ///  parse trees and extract data appropriately.
-  static String toStringTree(Tree t, {Parser recog, List<String> ruleNames}) {
-    ruleNames ??= recog?.ruleNames;
-    var s = escapeWhitespace(getNodeText(t, ruleNames: ruleNames), false);
-    if (t.childCount == 0) return s;
-    final buf = StringBuffer();
-    buf.write('(');
-    s = escapeWhitespace(getNodeText(t, ruleNames: ruleNames), false);
-    buf.write(s);
-    buf.write(' ');
-    for (var i = 0; i < t.childCount; i++) {
-      if (i > 0) buf.write(' ');
-      buf.write(toStringTree(t.getChild(i), ruleNames: ruleNames));
-    }
-    buf.write(')');
-    return buf.toString();
-  }
-
-  static String getNodeText(Tree t, {Parser recog, List<String> ruleNames}) {
-    ruleNames ??= recog?.ruleNames;
-    if (ruleNames != null) {
-      if (t is RuleContext) {
-        final ruleIndex = t.ruleContext.ruleIndex;
-        final ruleName = ruleNames[ruleIndex];
-        final altNumber = t.altNumber;
-        if (altNumber != ATN.INVALID_ALT_NUMBER) {
-          return ruleName + ':$altNumber';
-        }
-        return ruleName;
-      } else if (t is ErrorNode) {
-        return t.toString();
-      } else if (t is TerminalNode) {
-        final symbol = (t).symbol;
-        if (symbol != null) {
-          final s = symbol.text;
-          return s;
-        }
-      }
-    }
-    // no recog for rule names
-    Object payload = t.payload;
-    if (payload is Token) {
-      return payload.text;
-    }
-    return t.payload.toString();
-  }
-
-  /// Return ordered list of all children of this node */
-  static List<Tree> getChildren(Tree t) {
-    final kids = <Tree>[];
-    for (var i = 0; i < t.childCount; i++) {
-      kids.add(t.getChild(i));
-    }
-    return kids;
-  }
-
-  /// Return a list of all ancestors of this node.  The first node of
-  ///  list is the root and the last is the parent of this node.
-  ///
-  ///  @since 4.5.1
-  static List<Tree> getAncestors(Tree t) {
-    if (t.parent == null) return [];
-    final ancestors = <Tree>[];
-    t = t.parent;
-    while (t != null) {
-      ancestors.insert(0, t); // insert at start
-      t = t.parent;
-    }
-    return ancestors;
-  }
-
-  /// Return true if t is u's parent or a node on path to root from u.
-  ///  Use == not equals().
-  ///
-  ///  @since 4.5.1
-  static bool isAncestorOf(Tree t, Tree u) {
-    if (t == null || u == null || t.parent == null) return false;
-    var p = u.parent;
-    while (p != null) {
-      if (t == p) return true;
-      p = p.parent;
-    }
-    return false;
-  }
-
-  static List<ParseTree> findAllTokenNodes(ParseTree t, int ttype) {
-    return findAllNodes(t, ttype, true);
-  }
-
-  static List<ParseTree> findAllRuleNodes(ParseTree t, int ruleIndex) {
-    return findAllNodes(t, ruleIndex, false);
-  }
-
-  static List<ParseTree> findAllNodes(ParseTree t, int index, bool findTokens) {
-    final nodes = <ParseTree>[];
-    _findAllNodes(t, index, findTokens, nodes);
-    return nodes;
-  }
-
-  static void _findAllNodes(
-      ParseTree t, int index, bool findTokens, List<ParseTree> nodes) {
-    // check this node (the root) first
-    if (findTokens && t is TerminalNode) {
-      final tnode = t;
-      if (tnode.symbol.type == index) nodes.add(t);
-    } else if (!findTokens && t is ParserRuleContext) {
-      final ctx = t;
-      if (ctx.ruleIndex == index) nodes.add(t);
-    }
-    // check children
-    for (var i = 0; i < t.childCount; i++) {
-      _findAllNodes(t.getChild(i), index, findTokens, nodes);
-    }
-  }
-
-  /// Get all descendents; includes t itself.
-  ///
-  /// @since 4.5.1
-  static List<ParseTree> getDescendants(ParseTree t) {
-    final nodes = <ParseTree>[];
-    nodes.add(t);
-
-    final n = t.childCount;
-    for (var i = 0; i < n; i++) {
-      nodes.addAll(getDescendants(t.getChild(i)));
-    }
-    return nodes;
-  }
-
-  /// @deprecated */
-  static List<ParseTree> descendants(ParseTree t) {
-    return getDescendants(t);
-  }
-
-  /// Find smallest subtree of t enclosing range startTokenIndex..stopTokenIndex
-  ///  inclusively using postorder traversal.  Recursive depth-first-search.
-  ///
-  ///  @since 4.5.1
-  static ParserRuleContext getRootOfSubtreeEnclosingRegion(
-      ParseTree t,
-      int startTokenIndex, // inclusive
-      int stopTokenIndex) // inclusive
-  {
-    final n = t.childCount;
-    for (var i = 0; i < n; i++) {
-      final child = t.getChild(i);
-      final r = getRootOfSubtreeEnclosingRegion(
-          child, startTokenIndex, stopTokenIndex);
-      if (r != null) return r;
-    }
-    if (t is ParserRuleContext) {
-      final r = t;
-      if (startTokenIndex >=
-              r.start.tokenIndex && // is range fully contained in t?
-          (r.stop == null || stopTokenIndex <= r.stop.tokenIndex)) {
-        // note: r.getStop()==null likely implies that we bailed out of parser and there's nothing to the right
-        return r;
-      }
-    }
-    return null;
-  }
-
-  /// Replace any subtree siblings of root that are completely to left
-  ///  or right of lookahead range with a CommonToken(Token.INVALID_TYPE,"...")
-  ///  node. The source interval for t is not altered to suit smaller range!
-  ///
-  ///  WARNING: destructive to t.
-  ///
-  ///  @since 4.5.1
-  static void stripChildrenOutOfRange(ParserRuleContext t,
-      ParserRuleContext root, int startIndex, int stopIndex) {
-    if (t == null) return;
-    for (var i = 0; i < t.childCount; i++) {
-      final child = t.getChild(i);
-      final range = child.sourceInterval;
-      if (child is ParserRuleContext &&
-          (range.b < startIndex || range.a > stopIndex)) {
-        if (isAncestorOf(child, root)) {
-          // replace only if subtree doesn't have displayed root
-          final abbrev = CommonToken(Token.INVALID_TYPE, text: '...');
-          t.children[i] = TerminalNodeImpl(abbrev);
-        }
-      }
-    }
-  }
-
-  /// Return first node satisfying the pred
-  ///
-  ///  @since 4.5.1
-  static Tree findNodeSuchThat(Tree t, Predicate<Tree> pred) {
-    if (pred.test(t)) return t;
-
-    if (t == null) return null;
-
-    final n = t.childCount;
-    for (var i = 0; i < n; i++) {
-      final u = findNodeSuchThat(t.getChild(i), pred);
-      if (u != null) return u;
-    }
-    return null;
-  }
-}
-
-abstract class Predicate<T> {
-  bool test(T t);
-}

package/antlr4-4.9.2/lib/src/tree/tree.dart

@@ -1,10 +0,0 @@
-/*
- * Copyright (c) 2012-2017 The ANTLR Project. All rights reserved.
- * Use of this file is governed by the BSD 3-clause license that
- * can be found in the LICENSE.txt file in the project root.
- */
-
-export 'src/pattern/chunk.dart';
-export 'src/pattern/parse_tree_match.dart';
-export 'src/tree.dart';
-export 'src/trees.dart';