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

package/antlr4-4.9.2/lib/src/atn/src/profiling_atn_simulator.dart

@@ -1,229 +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:math';
-
-import '../../dfa/dfa.dart';
-import '../../parser.dart';
-import '../../parser_rule_context.dart';
-import '../../token_stream.dart';
-import '../../util/bit_set.dart';
-import 'atn_config_set.dart';
-import 'atn_simulator.dart';
-import 'info.dart';
-import 'parser_atn_simulator.dart';
-import 'semantic_context.dart';
-
-class ProfilingATNSimulator extends ParserATNSimulator {
-  List<DecisionInfo> decisions;
-  int numDecisions;
-
-  int _sllStopIndex;
-  int _llStopIndex;
-
-  int currentDecision;
-  DFAState currentState;
-
-  /// At the point of LL failover, we record how SLL would resolve the conflict so that
-  ///  we can determine whether or not a decision / input pair is context-sensitive.
-  ///  If LL gives a different result than SLL's predicted alternative, we have a
-  ///  context sensitivity for sure. The converse is not necessarily true, however.
-  ///  It's possible that after conflict resolution chooses minimum alternatives,
-  ///  SLL could get the same answer as LL. Regardless of whether or not the result indicates
-  ///  an ambiguity, it is not treated as a context sensitivity because LL prediction
-  ///  was not required in order to produce a correct prediction for this decision and input sequence.
-  ///  It may in fact still be a context sensitivity but we don't know by looking at the
-  ///  minimum alternatives for the current input.
-  int conflictingAltResolvedBySLL;
-
-  ProfilingATNSimulator(Parser parser)
-      : super(parser, parser.interpreter.atn, parser.interpreter.decisionToDFA,
-            parser.interpreter.sharedContextCache) {
-    numDecisions = atn.decisionToState.length;
-    decisions = List<DecisionInfo>(numDecisions);
-    for (var i = 0; i < numDecisions; i++) {
-      decisions[i] = DecisionInfo(i);
-    }
-  }
-
-  @override
-  int adaptivePredict(
-      TokenStream input, int decision, ParserRuleContext outerContext) {
-    try {
-      _sllStopIndex = -1;
-      _llStopIndex = -1;
-      currentDecision = decision;
-
-      final start =
-          DateTime.now(); // TODO get nano seconds expensive but useful info
-      final alt = super.adaptivePredict(input, decision, outerContext);
-      final stop = DateTime.now();
-      decisions[decision].timeInPrediction +=
-          (stop.difference(start)).inMicroseconds;
-      decisions[decision].invocations++;
-
-      final SLL_k = _sllStopIndex - startIndex + 1;
-      decisions[decision].SLL_TotalLook += SLL_k;
-      decisions[decision].SLL_MinLook = decisions[decision].SLL_MinLook == 0
-          ? SLL_k
-          : min(decisions[decision].SLL_MinLook, SLL_k);
-      if (SLL_k > decisions[decision].SLL_MaxLook) {
-        decisions[decision].SLL_MaxLook = SLL_k;
-        decisions[decision].SLL_MaxLookEvent = LookaheadEventInfo(
-            decision, null, alt, input, startIndex, _sllStopIndex, false);
-      }
-
-      if (_llStopIndex >= 0) {
-        final LL_k = _llStopIndex - startIndex + 1;
-        decisions[decision].LL_TotalLook += LL_k;
-        decisions[decision].LL_MinLook = decisions[decision].LL_MinLook == 0
-            ? LL_k
-            : min(decisions[decision].LL_MinLook, LL_k);
-        if (LL_k > decisions[decision].LL_MaxLook) {
-          decisions[decision].LL_MaxLook = LL_k;
-          decisions[decision].LL_MaxLookEvent = LookaheadEventInfo(
-              decision, null, alt, input, startIndex, _llStopIndex, true);
-        }
-      }
-
-      return alt;
-    } finally {
-      currentDecision = -1;
-    }
-  }
-
-  @override
-  DFAState getExistingTargetState(DFAState previousD, int t) {
-    // this method is called after each time the input position advances
-    // during SLL prediction
-    _sllStopIndex = input.index;
-
-    final existingTargetState = super.getExistingTargetState(previousD, t);
-    if (existingTargetState != null) {
-      decisions[currentDecision]
-          .SLL_DFATransitions++; // count only if we transition over a DFA state
-      if (existingTargetState == ATNSimulator.ERROR) {
-        decisions[currentDecision].errors.add(ErrorInfo(currentDecision,
-            previousD.configs, input, startIndex, _sllStopIndex, false));
-      }
-    }
-
-    currentState = existingTargetState;
-    return existingTargetState;
-  }
-
-  @override
-  DFAState computeTargetState(DFA dfa, DFAState previousD, int t) {
-    final state = super.computeTargetState(dfa, previousD, t);
-    currentState = state;
-    return state;
-  }
-
-  @override
-  ATNConfigSet computeReachSet(ATNConfigSet closure, int t, bool fullCtx) {
-    if (fullCtx) {
-      // this method is called after each time the input position advances
-      // during full context prediction
-      _llStopIndex = input.index;
-    }
-
-    final reachConfigs = super.computeReachSet(closure, t, fullCtx);
-    if (fullCtx) {
-      decisions[currentDecision]
-          .LL_ATNTransitions++; // count computation even if error
-      if (reachConfigs != null) {
-      } else {
-        // no reach on current lookahead symbol. ERROR.
-        // TODO: does not handle delayed errors per getSynValidOrSemInvalidAltThatFinishedDecisionEntryRule()
-        decisions[currentDecision].errors.add(ErrorInfo(
-            currentDecision, closure, input, startIndex, _llStopIndex, true));
-      }
-    } else {
-      decisions[currentDecision].SLL_ATNTransitions++;
-      if (reachConfigs != null) {
-      } else {
-        // no reach on current lookahead symbol. ERROR.
-        decisions[currentDecision].errors.add(ErrorInfo(
-            currentDecision, closure, input, startIndex, _sllStopIndex, false));
-      }
-    }
-    return reachConfigs;
-  }
-
-  @override
-  bool evalSemanticContextOne(SemanticContext pred,
-      ParserRuleContext parserCallStack, int alt, bool fullCtx) {
-    final result =
-        super.evalSemanticContextOne(pred, parserCallStack, alt, fullCtx);
-    if (!(pred is PrecedencePredicate)) {
-      final fullContext = _llStopIndex >= 0;
-      final stopIndex = fullContext ? _llStopIndex : _sllStopIndex;
-      decisions[currentDecision].predicateEvals.add(PredicateEvalInfo(
-          currentDecision,
-          input,
-          startIndex,
-          stopIndex,
-          pred,
-          result,
-          alt,
-          fullCtx));
-    }
-
-    return result;
-  }
-
-  @override
-  void reportAttemptingFullContext(DFA dfa, BitSet conflictingAlts,
-      ATNConfigSet configs, int startIndex, int stopIndex) {
-    if (conflictingAlts != null) {
-      conflictingAltResolvedBySLL = conflictingAlts.nextset(0);
-    } else {
-      conflictingAltResolvedBySLL = configs.alts.nextset(0);
-    }
-    decisions[currentDecision].LL_Fallback++;
-    super.reportAttemptingFullContext(
-        dfa, conflictingAlts, configs, startIndex, stopIndex);
-  }
-
-  @override
-  void reportContextSensitivity(DFA dfa, int prediction, ATNConfigSet configs,
-      int startIndex, int stopIndex) {
-    if (prediction != conflictingAltResolvedBySLL) {
-      decisions[currentDecision].contextSensitivities.add(
-          ContextSensitivityInfo(
-              currentDecision, configs, input, startIndex, stopIndex));
-    }
-    super.reportContextSensitivity(
-        dfa, prediction, configs, startIndex, stopIndex);
-  }
-
-  @override
-  void reportAmbiguity(DFA dfa, DFAState D, int startIndex, int stopIndex,
-      bool exact, BitSet ambigAlts, ATNConfigSet configs) {
-    final prediction =
-        ambigAlts != null ? ambigAlts.nextset(0) : configs.alts.nextset(0);
-    if (configs.fullCtx && prediction != conflictingAltResolvedBySLL) {
-      // Even though this is an ambiguity we are reporting, we can
-      // still detect some context sensitivities.  Both SLL and LL
-      // are showing a conflict, hence an ambiguity, but if they resolve
-      // to different minimum alternatives we have also identified a
-      // context sensitivity.
-      decisions[currentDecision].contextSensitivities.add(
-          ContextSensitivityInfo(
-              currentDecision, configs, input, startIndex, stopIndex));
-    }
-    decisions[currentDecision].ambiguities.add(AmbiguityInfo(currentDecision,
-        configs, ambigAlts, input, startIndex, stopIndex, configs.fullCtx));
-    super.reportAmbiguity(
-        dfa, D, startIndex, stopIndex, exact, ambigAlts, configs);
-  }
-
-  // ---------------------------------------------------------------------
-
-  List<DecisionInfo> get decisionInfo {
-    return decisions;
-  }
-}

package/antlr4-4.9.2/lib/src/atn/src/semantic_context.dart

@@ -1,404 +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 'package:collection/collection.dart';
-
-import '../../recognizer.dart';
-import '../../rule_context.dart';
-import '../../util/murmur_hash.dart';
-
-/// A tree structure used to record the semantic context in which
-///  an ATN configuration is valid.  It's either a single predicate,
-///  a conjunction {@code p1&&p2}, or a sum of products {@code p1||p2}.
-///
-///  <p>I have scoped the [AND], [OR], and [Predicate] subclasses of
-///  [SemanticContext] within the scope of this outer class.</p>
-abstract class SemanticContext {
-  /// The default [SemanticContext], which is semantically equivalent to
-  /// a predicate of the form {@code {true}?}.
-  static const SemanticContext NONE = Predicate();
-
-  const SemanticContext();
-
-  /// For context independent predicates, we evaluate them without a local
-  /// context (i.e., null context). That way, we can evaluate them without
-  /// having to create proper rule-specific context during prediction (as
-  /// opposed to the parser, which creates them naturally). In a practical
-  /// sense, this avoids a cast exception from RuleContext to myruleContext.
-  ///
-  /// <p>For context dependent predicates, we must pass in a local context so that
-  /// references such as $arg evaluate properly as _localctx.arg. We only
-  /// capture context dependent predicates in the context in which we begin
-  /// prediction, so we passed in the outer context here in case of context
-  /// dependent predicate evaluation.</p>
-  bool eval(Recognizer parser, RuleContext parserCallStack);
-
-  /// Evaluate the precedence predicates for the context and reduce the result.
-  ///
-  /// @param parser The parser instance.
-  /// @param parserCallStack
-  /// @return The simplified semantic context after precedence predicates are
-  /// evaluated, which will be one of the following values.
-  /// <ul>
-  /// <li>{@link #NONE}in if the predicate simplifies to [true] after
-  /// precedence predicates are evaluated.</li>
-  /// <li>nullin if the predicate simplifies to [false] after
-  /// precedence predicates are evaluated.</li>
-  /// <li>[this]in if the semantic context is not changed as a result of
-  /// precedence predicate evaluation.</li>
-  /// <li>A non-null [SemanticContext]in the new simplified
-  /// semantic context after precedence predicates are evaluated.</li>
-  /// </ul>
-  SemanticContext evalPrecedence(Recognizer parser,
-      RuleContext parserCallStack) {
-    return this;
-  }
-
-  static SemanticContext and(SemanticContext a, SemanticContext b) {
-    if (a == null || a == NONE) return b;
-    if (b == null || b == NONE) return a;
-    final result = AND(a, b);
-    if (result.opnds.length == 1) {
-      return result.opnds[0];
-    }
-
-    return result;
-  }
-
-  ///
-  ///  @see ParserATNSimulator#getPredsForAmbigAlts
-  static SemanticContext or(SemanticContext a, SemanticContext b) {
-    if (a == null) return b;
-    if (b == null) return a;
-    if (a == NONE || b == NONE) return NONE;
-    final result = OR(a, b);
-    if (result.opnds.length == 1) {
-      return result.opnds[0];
-    }
-
-    return result;
-  }
-
-  static Iterable<PrecedencePredicate> filterPrecedencePredicates(
-      Iterable<SemanticContext> collection) {
-    return collection.whereType<PrecedencePredicate>();
-  }
-
-  static Iterable<SemanticContext> filterNonPrecedencePredicates(
-      Iterable<SemanticContext> collection) {
-    return collection.where((e) => !(e is PrecedencePredicate));
-  }
-}
-
-class Predicate extends SemanticContext {
-  final int ruleIndex;
-  final int predIndex;
-  final bool isCtxDependent; // e.g., $i ref in pred
-
-  const Predicate(
-      [this.ruleIndex = -1, this.predIndex = -1, this.isCtxDependent = false]);
-
-  @override
-  bool eval(Recognizer parser, RuleContext parserCallStack) {
-    final localctx = isCtxDependent ? parserCallStack : null;
-    return parser.sempred(localctx, ruleIndex, predIndex);
-  }
-
-  @override
-  int get hashCode {
-    var hashCode = MurmurHash.initialize();
-    hashCode = MurmurHash.update(hashCode, ruleIndex);
-    hashCode = MurmurHash.update(hashCode, predIndex);
-    hashCode = MurmurHash.update(hashCode, isCtxDependent ? 1 : 0);
-    hashCode = MurmurHash.finish(hashCode, 3);
-    return hashCode;
-  }
-
-  @override
-  bool operator ==(Object obj) {
-    return obj is Predicate &&
-        ruleIndex == obj.ruleIndex &&
-        predIndex == obj.predIndex &&
-        isCtxDependent == obj.isCtxDependent;
-  }
-
-  @override
-  String toString() {
-    return '{$ruleIndex:$predIndex}?';
-  }
-}
-
-class PrecedencePredicate extends SemanticContext
-    implements Comparable<PrecedencePredicate> {
-  final int precedence;
-
-  PrecedencePredicate([this.precedence = 0]);
-
-  @override
-  bool eval(Recognizer parser, RuleContext parserCallStack) {
-    return parser.precpred(parserCallStack, precedence);
-  }
-
-  @override
-  SemanticContext evalPrecedence(Recognizer parser,
-      RuleContext parserCallStack) {
-    if (parser.precpred(parserCallStack, precedence)) {
-      return SemanticContext.NONE;
-    } else {
-      return null;
-    }
-  }
-
-  @override
-  int compareTo(PrecedencePredicate o) {
-    return precedence - o.precedence;
-  }
-
-  @override
-  int get hashCode {
-    var hashCode = 1;
-    hashCode = 31 * hashCode + precedence;
-    return hashCode;
-  }
-
-  @override
-  bool operator ==(Object obj) {
-    if (!(obj is PrecedencePredicate)) {
-      return false;
-    }
-    PrecedencePredicate other = obj;
-    return precedence == other.precedence;
-  }
-
-// precedence >= _precedenceStack.peek()
-  @override
-  String toString() {
-    return '{$precedence>=prec}?';
-  }
-}
-
-/// This is the base class for semantic context "operators", which operate on
-/// a collection of semantic context "operands".
-///
-/// @since 4.3
-abstract class Operator extends SemanticContext {
-  /// Gets the operands for the semantic context operator.
-  ///
-  /// @return a collection of [SemanticContext] operands for the
-  /// operator.
-  ///
-  /// @since 4.3
-  List<SemanticContext> get operands;
-}
-
-/// A semantic context which is true whenever none of the contained contexts
-/// is false.
-
-class AND extends Operator {
-  List<SemanticContext> opnds;
-
-  AND(SemanticContext a, SemanticContext b) {
-    var operands = <SemanticContext>{};
-    if (a is AND) {
-      operands.addAll(a.opnds);
-    } else {
-      operands.add(a);
-    }
-    if (b is AND) {
-      operands.addAll(b.opnds);
-    } else {
-      operands.add(b);
-    }
-
-    final precedencePredicates =
-    SemanticContext.filterPrecedencePredicates(operands);
-
-    operands = SemanticContext.filterNonPrecedencePredicates(operands).toSet();
-    if (precedencePredicates.isNotEmpty) {
-      // interested in the transition with the lowest precedence
-      final reduced =
-      precedencePredicates.reduce((a, b) => a.compareTo(b) <= 0 ? a : b);
-      operands.add(reduced);
-    }
-
-    opnds = operands.toList();
-  }
-
-  @override
-  List<SemanticContext> get operands {
-    return opnds;
-  }
-
-  @override
-  bool operator ==(Object obj) {
-    if (!(obj is AND)) return false;
-    AND other = obj;
-    return ListEquality().equals(opnds, other.opnds);
-  }
-
-  @override
-  int get hashCode {
-    return MurmurHash.getHashCode(opnds, runtimeType.hashCode);
-  }
-
-  /// {@inheritDoc}
-  ///
-  /// <p>
-  /// The evaluation of predicates by this context is short-circuiting, but
-  /// unordered.</p>
-
-  @override
-  bool eval(Recognizer parser, RuleContext parserCallStack) {
-    for (var opnd in opnds) {
-      if (!opnd.eval(parser, parserCallStack)) return false;
-    }
-    return true;
-  }
-
-  @override
-  SemanticContext evalPrecedence(Recognizer parser,
-      RuleContext parserCallStack) {
-    var differs = false;
-    final operands = <SemanticContext>[];
-    for (var context in opnds) {
-      final evaluated =
-      context.evalPrecedence(parser, parserCallStack);
-      differs |= (evaluated != context);
-      if (evaluated == null) {
-        // The AND context is false if any element is false
-        return null;
-      } else if (evaluated != SemanticContext.NONE) {
-        // Reduce the result by skipping true elements
-        operands.add(evaluated);
-      }
-    }
-
-    if (!differs) {
-      return this;
-    }
-
-    if (operands.isEmpty) {
-      // all elements were true, so the AND context is true
-      return SemanticContext.NONE;
-    }
-
-    var result = operands[0];
-    for (var i = 1; i < operands.length; i++) {
-      result = SemanticContext.and(result, operands[i]);
-    }
-
-    return result;
-  }
-
-  @override
-  String toString() {
-    return opnds.join('&&');
-  }
-}
-
-/// A semantic context which is true whenever at least one of the contained
-/// contexts is true.
-class OR extends Operator {
-  List<SemanticContext> opnds;
-
-  OR(SemanticContext a, SemanticContext b) {
-    var operands = <SemanticContext>{};
-    if (a is OR) {
-      operands.addAll(a.opnds);
-    } else {
-      operands.add(a);
-    }
-    if (b is OR) {
-      operands.addAll(b.opnds);
-    } else {
-      operands.add(b);
-    }
-
-    final precedencePredicates =
-    SemanticContext.filterPrecedencePredicates(operands);
-
-    operands = SemanticContext.filterNonPrecedencePredicates(operands).toSet();
-    if (precedencePredicates.isNotEmpty) {
-      // interested in the transition with the highest precedence
-      final reduced =
-      precedencePredicates.reduce((a, b) => a.compareTo(b) >= 0 ? a : b);
-      operands.add(reduced);
-    }
-
-    opnds = operands.toList();
-  }
-
-  @override
-  List<SemanticContext> get operands {
-    return opnds;
-  }
-
-  @override
-  bool operator ==(Object obj) {
-    if (!(obj is OR)) return false;
-    OR other = obj;
-    return ListEquality().equals(opnds, other.opnds);
-  }
-
-  @override
-  int get hashCode {
-    return MurmurHash.getHashCode(opnds, runtimeType.hashCode);
-  }
-
-  /// {@inheritDoc}
-  ///
-  /// <p>
-  /// The evaluation of predicates by this context is short-circuiting, but
-  /// unordered.</p>
-
-  @override
-  bool eval(Recognizer parser, RuleContext parserCallStack) {
-    for (var opnd in opnds) {
-      if (opnd.eval(parser, parserCallStack)) return true;
-    }
-    return false;
-  }
-
-  @override
-  SemanticContext evalPrecedence(Recognizer parser,
-      RuleContext parserCallStack) {
-    var differs = false;
-    final operands = <SemanticContext>[];
-    for (var context in opnds) {
-      final evaluated =
-      context.evalPrecedence(parser, parserCallStack);
-      differs |= (evaluated != context);
-      if (evaluated == SemanticContext.NONE) {
-        // The OR context is true if any element is true
-        return SemanticContext.NONE;
-      } else if (evaluated != null) {
-        // Reduce the result by skipping false elements
-        operands.add(evaluated);
-      }
-    }
-
-    if (!differs) {
-      return this;
-    }
-
-    if (operands.isEmpty) {
-      // all elements were false, so the OR context is false
-      return null;
-    }
-
-    var result = operands[0];
-    for (var i = 1; i < operands.length; i++) {
-      result = SemanticContext.or(result, operands[i]);
-    }
-
-    return result;
-  }
-
-  @override
-  String toString() {
-    return opnds.join('||');
-  }
-}