wehub-resource-sync
471 lines
25 KiB
Diff
471 lines
25 KiB
Diff
diff --git a/ANTLRInputStream.js b/ANTLRInputStream.js
|
|
index eaeb0800e83d2a4bd21699ff5fc8b0bb8920efbb..ed6c85c047d1ead64653e212d579967536dca664 100644
|
|
--- a/ANTLRInputStream.js
|
|
+++ b/ANTLRInputStream.js
|
|
@@ -43,7 +43,7 @@ class ANTLRInputStream {
|
|
}
|
|
consume() {
|
|
if (this.p >= this.n) {
|
|
- assert(this.LA(1) === IntStream_1.IntStream.EOF);
|
|
+ assert.ok(this.LA(1) === IntStream_1.IntStream.EOF);
|
|
throw new Error("cannot consume EOF");
|
|
}
|
|
//System.out.println("prev p="+p+", c="+(char)data[p]);
|
|
diff --git a/BufferedTokenStream.js b/BufferedTokenStream.js
|
|
index 9a3c6d19bf959819d96552d73267f93985a6fd67..11511d985b9b2b7dd0b140579032a0929d0a4342 100644
|
|
--- a/BufferedTokenStream.js
|
|
+++ b/BufferedTokenStream.js
|
|
@@ -126,7 +126,7 @@ let BufferedTokenStream = class BufferedTokenStream {
|
|
* @see #get(int i)
|
|
*/
|
|
sync(i) {
|
|
- assert(i >= 0);
|
|
+ assert.ok(i >= 0);
|
|
let n = i - this.tokens.length + 1; // how many more elements we need?
|
|
//System.out.println("sync("+i+") needs "+n);
|
|
if (n > 0) {
|
|
@@ -251,7 +251,7 @@ let BufferedTokenStream = class BufferedTokenStream {
|
|
getTokens(start, stop, types) {
|
|
this.lazyInit();
|
|
if (start === undefined) {
|
|
- assert(stop === undefined && types === undefined);
|
|
+ assert.ok(stop === undefined && types === undefined);
|
|
return this.tokens;
|
|
}
|
|
else if (stop === undefined) {
|
|
diff --git a/CodePointBuffer.js b/CodePointBuffer.js
|
|
index 7d50d372da9a1ccae48f55dd6e5ee388f583ace1..f6452956227847a4e2477c8eb1017e56ec9a58d1 100644
|
|
--- a/CodePointBuffer.js
|
|
+++ b/CodePointBuffer.js
|
|
@@ -109,7 +109,7 @@ exports.CodePointBuffer = CodePointBuffer;
|
|
}
|
|
}
|
|
appendArrayByte(utf16In) {
|
|
- assert(this.prevHighSurrogate === -1);
|
|
+ assert.ok(this.prevHighSurrogate === -1);
|
|
let input = utf16In;
|
|
let inOffset = 0;
|
|
let inLimit = utf16In.length;
|
|
@@ -140,7 +140,7 @@ exports.CodePointBuffer = CodePointBuffer;
|
|
this.position = outOffset;
|
|
}
|
|
appendArrayChar(utf16In) {
|
|
- assert(this.prevHighSurrogate === -1);
|
|
+ assert.ok(this.prevHighSurrogate === -1);
|
|
let input = utf16In;
|
|
let inOffset = 0;
|
|
let inLimit = utf16In.length;
|
|
diff --git a/CodePointCharStream.js b/CodePointCharStream.js
|
|
index 4c5398f24afdd378b36053391611404018925f71..e507525f0976219da6eae78136625b8b5a42db67 100644
|
|
--- a/CodePointCharStream.js
|
|
+++ b/CodePointCharStream.js
|
|
@@ -28,7 +28,7 @@ class CodePointCharStream {
|
|
// construct instances of this type.
|
|
constructor(array, position, remaining, name) {
|
|
// TODO
|
|
- assert(position === 0);
|
|
+ assert.ok(position === 0);
|
|
this._array = array;
|
|
this._size = remaining;
|
|
this._name = name;
|
|
@@ -55,7 +55,7 @@ class CodePointCharStream {
|
|
}
|
|
consume() {
|
|
if (this._size - this._position === 0) {
|
|
- assert(this.LA(1) === IntStream_1.IntStream.EOF);
|
|
+ assert.ok(this.LA(1) === IntStream_1.IntStream.EOF);
|
|
throw new RangeError("cannot consume EOF");
|
|
}
|
|
this._position++;
|
|
diff --git a/atn/ATN.js b/atn/ATN.js
|
|
index 0da2b8e836510546583685253ec828dbdaa0c1db..4d812a850b6b010576396e6e610f6df25cb585c9 100644
|
|
--- a/atn/ATN.js
|
|
+++ b/atn/ATN.js
|
|
@@ -63,7 +63,7 @@ let ATN = class ATN {
|
|
return PredictionContext_1.PredictionContext.getCachedContext(context, this.contextCache, new PredictionContext_1.PredictionContext.IdentityHashMap());
|
|
}
|
|
getDecisionToDFA() {
|
|
- assert(this.decisionToDFA != null && this.decisionToDFA.length === this.decisionToState.length);
|
|
+ assert.ok(this.decisionToDFA != null && this.decisionToDFA.length === this.decisionToState.length);
|
|
return this.decisionToDFA;
|
|
}
|
|
nextTokens(s, ctx) {
|
|
diff --git a/atn/ATNConfig.js b/atn/ATNConfig.js
|
|
index 480d569b667f29437aeef8f2b9e6b0d3187c565f..bcacbc91ea61488f4b8e2ef40960c4f25a168758 100644
|
|
--- a/atn/ATNConfig.js
|
|
+++ b/atn/ATNConfig.js
|
|
@@ -61,7 +61,7 @@ const SUPPRESS_PRECEDENCE_FILTER = 0x80000000;
|
|
let ATNConfig = class ATNConfig {
|
|
constructor(state, altOrConfig, context) {
|
|
if (typeof altOrConfig === "number") {
|
|
- assert((altOrConfig & 0xFFFFFF) === altOrConfig);
|
|
+ assert.ok((altOrConfig & 0xFFFFFF) === altOrConfig);
|
|
this._state = state;
|
|
this.altAndOuterContextDepth = altOrConfig;
|
|
this._context = context;
|
|
@@ -120,7 +120,7 @@ let ATNConfig = class ATNConfig {
|
|
return (this.altAndOuterContextDepth >>> 24) & 0x7F;
|
|
}
|
|
set outerContextDepth(outerContextDepth) {
|
|
- assert(outerContextDepth >= 0);
|
|
+ assert.ok(outerContextDepth >= 0);
|
|
// saturate at 0x7F - everything but zero/positive is only used for debug information anyway
|
|
outerContextDepth = Math.min(outerContextDepth, 0x7F);
|
|
this.altAndOuterContextDepth = ((outerContextDepth << 24) | (this.altAndOuterContextDepth & ~0x7F000000) >>> 0);
|
|
diff --git a/atn/ATNConfigSet.js b/atn/ATNConfigSet.js
|
|
index 3ce0361c4ce7fef06b07a9a24c23251fd31dc0d1..f92be1dbeeed37a69b2aa3022ac5a7b7b29040f1 100644
|
|
--- a/atn/ATNConfigSet.js
|
|
+++ b/atn/ATNConfigSet.js
|
|
@@ -125,7 +125,7 @@ class ATNConfigSet {
|
|
if (this.outermostConfigSet && !outermostConfigSet) {
|
|
throw new Error("IllegalStateException");
|
|
}
|
|
- assert(!outermostConfigSet || !this._dipsIntoOuterContext);
|
|
+ assert.ok(!outermostConfigSet || !this._dipsIntoOuterContext);
|
|
this.outermostConfigSet = outermostConfigSet;
|
|
}
|
|
getStates() {
|
|
@@ -193,7 +193,7 @@ class ATNConfigSet {
|
|
if (!this.mergedConfigs || !this.unmerged) {
|
|
throw new Error("Covered by ensureWritable but duplicated here for strict null check limitation");
|
|
}
|
|
- assert(!this.outermostConfigSet || !e.reachesIntoOuterContext);
|
|
+ assert.ok(!this.outermostConfigSet || !e.reachesIntoOuterContext);
|
|
if (contextCache == null) {
|
|
contextCache = PredictionContextCache_1.PredictionContextCache.UNCACHED;
|
|
}
|
|
@@ -247,7 +247,7 @@ class ATNConfigSet {
|
|
updatePropertiesForMergedConfig(config) {
|
|
// merged configs can't change the alt or semantic context
|
|
this._dipsIntoOuterContext = this._dipsIntoOuterContext || config.reachesIntoOuterContext;
|
|
- assert(!this.outermostConfigSet || !this._dipsIntoOuterContext);
|
|
+ assert.ok(!this.outermostConfigSet || !this._dipsIntoOuterContext);
|
|
}
|
|
updatePropertiesForAddedConfig(config) {
|
|
if (this.configs.length === 1) {
|
|
@@ -258,7 +258,7 @@ class ATNConfigSet {
|
|
}
|
|
this._hasSemanticContext = this._hasSemanticContext || !SemanticContext_1.SemanticContext.NONE.equals(config.semanticContext);
|
|
this._dipsIntoOuterContext = this._dipsIntoOuterContext || config.reachesIntoOuterContext;
|
|
- assert(!this.outermostConfigSet || !this._dipsIntoOuterContext);
|
|
+ assert.ok(!this.outermostConfigSet || !this._dipsIntoOuterContext);
|
|
}
|
|
canMerge(left, leftKey, right) {
|
|
if (left.state.stateNumber !== right.state.stateNumber) {
|
|
diff --git a/atn/LexerATNSimulator.js b/atn/LexerATNSimulator.js
|
|
index d461d2063dddc78bbb15e56e5ae2559aadd3320d..c92994d52e226965e47a7e1fb28e8100252b289b 100644
|
|
--- a/atn/LexerATNSimulator.js
|
|
+++ b/atn/LexerATNSimulator.js
|
|
@@ -258,7 +258,7 @@ let LexerATNSimulator = class LexerATNSimulator extends ATNSimulator_1.ATNSimula
|
|
config = c.transform(target, true, lexerActionExecutor);
|
|
}
|
|
else {
|
|
- assert(c.lexerActionExecutor == null);
|
|
+ assert.ok(c.lexerActionExecutor == null);
|
|
config = c.transform(target, true);
|
|
}
|
|
let treatEofAsEpsilon = t === IntStream_1.IntStream.EOF;
|
|
@@ -543,7 +543,7 @@ let LexerATNSimulator = class LexerATNSimulator extends ATNSimulator_1.ATNSimula
|
|
/* the lexer evaluates predicates on-the-fly; by this point configs
|
|
* should not contain any configurations with unevaluated predicates.
|
|
*/
|
|
- assert(!configs.hasSemanticContext);
|
|
+ assert.ok(!configs.hasSemanticContext);
|
|
let proposed = new DFAState_1.DFAState(configs);
|
|
let existing = this.atn.modeToDFA[this.mode].states.get(proposed);
|
|
if (existing != null) {
|
|
diff --git a/atn/ParserATNSimulator.js b/atn/ParserATNSimulator.js
|
|
index c36395116d11c431b9f9ea5fea8afbc458bd0b50..0093ac18c7e31fe15bc0596e4f0886b199f41596 100644
|
|
--- a/atn/ParserATNSimulator.js
|
|
+++ b/atn/ParserATNSimulator.js
|
|
@@ -307,7 +307,7 @@ let ParserATNSimulator = class ParserATNSimulator extends ATNSimulator_1.ATNSimu
|
|
useContext = false;
|
|
}
|
|
let dfa = this.atn.decisionToDFA[decision];
|
|
- assert(dfa != null);
|
|
+ assert.ok(dfa != null);
|
|
if (this.optimize_ll1 && !dfa.isPrecedenceDfa && !dfa.isEmpty) {
|
|
let ll_1 = input.LA(1);
|
|
if (ll_1 >= 0 && ll_1 <= 0xFFFF) {
|
|
@@ -381,7 +381,7 @@ let ParserATNSimulator = class ParserATNSimulator extends ATNSimulator_1.ATNSimu
|
|
return undefined;
|
|
}
|
|
let remainingContext = outerContext;
|
|
- assert(outerContext != null);
|
|
+ assert.ok(outerContext != null);
|
|
let s0;
|
|
if (dfa.isPrecedenceDfa) {
|
|
s0 = dfa.getPrecedenceStartState(this._parser.precedence, true);
|
|
@@ -393,7 +393,7 @@ let ParserATNSimulator = class ParserATNSimulator extends ATNSimulator_1.ATNSimu
|
|
remainingContext = this.skipTailCalls(remainingContext);
|
|
s0 = s0.getContextTarget(this.getReturnState(remainingContext));
|
|
if (remainingContext.isEmpty) {
|
|
- assert(s0 == null || !s0.isContextSensitive);
|
|
+ assert.ok(s0 == null || !s0.isContextSensitive);
|
|
}
|
|
else {
|
|
remainingContext = remainingContext.parent;
|
|
@@ -433,7 +433,7 @@ let ParserATNSimulator = class ParserATNSimulator extends ATNSimulator_1.ATNSimu
|
|
let initialState = new SimulatorState_1.SimulatorState(state.outerContext, s, state.useContext, remainingOuterContext);
|
|
return this.execATN(dfa, input, startIndex, initialState);
|
|
}
|
|
- assert(remainingOuterContext != null);
|
|
+ assert.ok(remainingOuterContext != null);
|
|
remainingOuterContext = remainingOuterContext.parent;
|
|
s = next;
|
|
}
|
|
@@ -456,7 +456,7 @@ let ParserATNSimulator = class ParserATNSimulator extends ATNSimulator_1.ATNSimu
|
|
break;
|
|
}
|
|
// t is not updated if one of these states is reached
|
|
- assert(!this.isAcceptState(s, state.useContext));
|
|
+ assert.ok(!this.isAcceptState(s, state.useContext));
|
|
// if no edge, pop over to ATN interpreter, update DFA and return
|
|
let target = this.getExistingTargetState(s, t);
|
|
if (target == null) {
|
|
@@ -508,7 +508,7 @@ let ParserATNSimulator = class ParserATNSimulator extends ATNSimulator_1.ATNSimu
|
|
//}
|
|
}
|
|
else {
|
|
- assert(!state.useContext);
|
|
+ assert.ok(!state.useContext);
|
|
// Before attempting full context prediction, check to see if there are
|
|
// disambiguating or validating predicates to evaluate which allow an
|
|
// immediate decision
|
|
@@ -664,9 +664,9 @@ let ParserATNSimulator = class ParserATNSimulator extends ATNSimulator_1.ATNSimu
|
|
}
|
|
let D = nextState.s0;
|
|
// predicted alt => accept state
|
|
- assert(D.isAcceptState || D.prediction === ATN_1.ATN.INVALID_ALT_NUMBER);
|
|
+ assert.ok(D.isAcceptState || D.prediction === ATN_1.ATN.INVALID_ALT_NUMBER);
|
|
// conflicted => accept state
|
|
- assert(D.isAcceptState || D.configs.conflictInfo == null);
|
|
+ assert.ok(D.isAcceptState || D.configs.conflictInfo == null);
|
|
if (this.isAcceptState(D, useContext)) {
|
|
let conflictingAlts = D.configs.conflictingAlts;
|
|
let predictedAlt = conflictingAlts == null ? D.prediction : ATN_1.ATN.INVALID_ALT_NUMBER;
|
|
@@ -731,8 +731,8 @@ let ParserATNSimulator = class ParserATNSimulator extends ATNSimulator_1.ATNSimu
|
|
return predictedAlt;
|
|
}
|
|
else {
|
|
- assert(!useContext);
|
|
- assert(this.isAcceptState(D, false));
|
|
+ assert.ok(!useContext);
|
|
+ assert.ok(this.isAcceptState(D, false));
|
|
if (ParserATNSimulator.debug) {
|
|
console.log("RETRY with outerContext=" + outerContext);
|
|
}
|
|
@@ -877,12 +877,12 @@ let ParserATNSimulator = class ParserATNSimulator extends ATNSimulator_1.ATNSimu
|
|
if (next == null) {
|
|
break;
|
|
}
|
|
- assert(remainingGlobalContext != null);
|
|
+ assert.ok(remainingGlobalContext != null);
|
|
remainingGlobalContext = remainingGlobalContext.parent;
|
|
s = next;
|
|
}
|
|
}
|
|
- assert(!this.isAcceptState(s, useContext));
|
|
+ assert.ok(!this.isAcceptState(s, useContext));
|
|
if (this.isAcceptState(s, useContext)) {
|
|
return new SimulatorState_1.SimulatorState(previous.outerContext, s, useContext, remainingGlobalContext);
|
|
}
|
|
@@ -896,7 +896,7 @@ let ParserATNSimulator = class ParserATNSimulator extends ATNSimulator_1.ATNSimu
|
|
if (target === ATNSimulator_1.ATNSimulator.ERROR) {
|
|
return undefined;
|
|
}
|
|
- assert(!useContext || !target.configs.dipsIntoOuterContext);
|
|
+ assert.ok(!useContext || !target.configs.dipsIntoOuterContext);
|
|
return new SimulatorState_1.SimulatorState(previous.outerContext, target, useContext, remainingGlobalContext);
|
|
}
|
|
/**
|
|
@@ -955,7 +955,7 @@ let ParserATNSimulator = class ParserATNSimulator extends ATNSimulator_1.ATNSimu
|
|
console.log("testing " + this.getTokenName(t) + " at " + c.toString());
|
|
}
|
|
if (c.state instanceof RuleStopState_1.RuleStopState) {
|
|
- assert(c.context.isEmpty);
|
|
+ assert.ok(c.context.isEmpty);
|
|
if (useContext && !c.reachesIntoOuterContext || t === IntStream_1.IntStream.EOF) {
|
|
if (skippedStopStates == null) {
|
|
skippedStopStates = [];
|
|
@@ -1018,7 +1018,7 @@ let ParserATNSimulator = class ParserATNSimulator extends ATNSimulator_1.ATNSimu
|
|
* multiple alternatives are viable.
|
|
*/
|
|
if (skippedStopStates != null && (!useContext || !PredictionMode_1.PredictionMode.hasConfigInRuleStopState(reach))) {
|
|
- assert(skippedStopStates.length > 0);
|
|
+ assert.ok(skippedStopStates.length > 0);
|
|
for (let c of skippedStopStates) {
|
|
reach.add(c, contextCache);
|
|
}
|
|
@@ -1382,7 +1382,7 @@ let ParserATNSimulator = class ParserATNSimulator extends ATNSimulator_1.ATNSimu
|
|
for (let i = 1; i < altToPred.length; i++) {
|
|
let pred = altToPred[i];
|
|
// unpredicated is indicated by SemanticContext.NONE
|
|
- assert(pred != null);
|
|
+ assert.ok(pred != null);
|
|
// find first unpredicated but ambig alternative, if any.
|
|
// Only ambiguous alternatives will have SemanticContext.NONE.
|
|
// Any unambig alts or ambig naked alts after first ambig naked are ignored
|
|
@@ -1497,7 +1497,7 @@ let ParserATNSimulator = class ParserATNSimulator extends ATNSimulator_1.ATNSimu
|
|
// Make sure we track that we are now out of context.
|
|
c.outerContextDepth = config.outerContextDepth;
|
|
c.isPrecedenceFilterSuppressed = config.isPrecedenceFilterSuppressed;
|
|
- assert(depth > MIN_INTEGER_VALUE);
|
|
+ assert.ok(depth > MIN_INTEGER_VALUE);
|
|
this.closureImpl(c, configs, intermediate, closureBusy, collectPredicates, hasMoreContexts, contextCache, depth - 1, treatEofAsEpsilon);
|
|
}
|
|
if (!hasEmpty || !hasMoreContexts) {
|
|
@@ -1587,7 +1587,7 @@ let ParserATNSimulator = class ParserATNSimulator extends ATNSimulator_1.ATNSimu
|
|
// avoid infinite recursion for right-recursive rules
|
|
continue;
|
|
}
|
|
- assert(newDepth > MIN_INTEGER_VALUE);
|
|
+ assert.ok(newDepth > MIN_INTEGER_VALUE);
|
|
newDepth--;
|
|
if (ParserATNSimulator.debug) {
|
|
console.log("dips into outer ctx: " + c);
|
|
@@ -1595,7 +1595,7 @@ let ParserATNSimulator = class ParserATNSimulator extends ATNSimulator_1.ATNSimu
|
|
}
|
|
else if (t instanceof RuleTransition_1.RuleTransition) {
|
|
if (this.optimize_tail_calls && t.optimizedTailCall && (!this.tail_call_preserves_sll || !PredictionContext_1.PredictionContext.isEmptyLocal(config.context))) {
|
|
- assert(c.context === config.context);
|
|
+ assert.ok(c.context === config.context);
|
|
if (newDepth === 0) {
|
|
// the pop/push of a tail call would keep the depth
|
|
// constant, except we latch if it goes negative
|
|
@@ -1926,7 +1926,7 @@ let ParserATNSimulator = class ParserATNSimulator extends ATNSimulator_1.ATNSimu
|
|
return false;
|
|
}
|
|
addDFAEdge(dfa, fromState, t, contextTransitions, toConfigs, contextCache) {
|
|
- assert(contextTransitions == null || contextTransitions.isEmpty || dfa.isContextSensitive);
|
|
+ assert.ok(contextTransitions == null || contextTransitions.isEmpty || dfa.isContextSensitive);
|
|
let from = fromState;
|
|
let to = this.addDFAState(dfa, toConfigs, contextCache);
|
|
if (contextTransitions != null) {
|
|
@@ -1944,7 +1944,7 @@ let ParserATNSimulator = class ParserATNSimulator extends ATNSimulator_1.ATNSimu
|
|
continue;
|
|
}
|
|
next = this.addDFAContextState(dfa, from.configs, context, contextCache);
|
|
- assert(context !== PredictionContext_1.PredictionContext.EMPTY_FULL_STATE_KEY || next.configs.isOutermostConfigSet);
|
|
+ assert.ok(context !== PredictionContext_1.PredictionContext.EMPTY_FULL_STATE_KEY || next.configs.isOutermostConfigSet);
|
|
from.setContextTarget(context, next);
|
|
from = next;
|
|
}
|
|
@@ -1973,7 +1973,7 @@ let ParserATNSimulator = class ParserATNSimulator extends ATNSimulator_1.ATNSimu
|
|
return this.addDFAState(dfa, contextConfigs, contextCache);
|
|
}
|
|
else {
|
|
- assert(!configs.isOutermostConfigSet, "Shouldn't be adding a duplicate edge.");
|
|
+ assert.ok(!configs.isOutermostConfigSet, "Shouldn't be adding a duplicate edge.");
|
|
configs = configs.clone(true);
|
|
configs.isOutermostConfigSet = true;
|
|
return this.addDFAState(dfa, configs, contextCache);
|
|
@@ -2081,7 +2081,7 @@ let ParserATNSimulator = class ParserATNSimulator extends ATNSimulator_1.ATNSimu
|
|
}
|
|
while (!context.isEmpty) {
|
|
let state = this.atn.states[context.invokingState];
|
|
- assert(state.numberOfTransitions === 1 && state.transition(0).serializationType === 3 /* RULE */);
|
|
+ assert.ok(state.numberOfTransitions === 1 && state.transition(0).serializationType === 3 /* RULE */);
|
|
let transition = state.transition(0);
|
|
if (!transition.tailCall) {
|
|
break;
|
|
diff --git a/atn/PredictionContext.js b/atn/PredictionContext.js
|
|
index 47d525fde0ca117193dd2b1cd2685420c23683d6..b269295802fc84b7cf7e1ce055cdba0a0c03ec53 100644
|
|
--- a/atn/PredictionContext.js
|
|
+++ b/atn/PredictionContext.js
|
|
@@ -118,7 +118,7 @@ class PredictionContext {
|
|
leftIndex++;
|
|
}
|
|
else {
|
|
- assert(context1.getReturnState(rightIndex) < context0.getReturnState(leftIndex));
|
|
+ assert.ok(context1.getReturnState(rightIndex) < context0.getReturnState(leftIndex));
|
|
parentsList[count] = context1.getParent(rightIndex);
|
|
returnStatesList[count] = context1.getReturnState(rightIndex);
|
|
canReturnLeft = false;
|
|
@@ -374,8 +374,8 @@ __decorate([
|
|
let ArrayPredictionContext = class ArrayPredictionContext extends PredictionContext {
|
|
constructor(parents, returnStates, hashCode) {
|
|
super(hashCode || PredictionContext.calculateHashCode(parents, returnStates));
|
|
- assert(parents.length === returnStates.length);
|
|
- assert(returnStates.length > 1 || returnStates[0] !== PredictionContext.EMPTY_FULL_STATE_KEY, "Should be using PredictionContext.EMPTY instead.");
|
|
+ assert.ok(parents.length === returnStates.length);
|
|
+ assert.ok(returnStates.length > 1 || returnStates[0] !== PredictionContext.EMPTY_FULL_STATE_KEY, "Should be using PredictionContext.EMPTY instead.");
|
|
this.parents = parents;
|
|
this.returnStates = returnStates;
|
|
}
|
|
@@ -458,7 +458,7 @@ let ArrayPredictionContext = class ArrayPredictionContext extends PredictionCont
|
|
result = new SingletonPredictionContext(updatedParents[0], updatedReturnStates[0]);
|
|
}
|
|
else {
|
|
- assert(updatedParents.length > 1);
|
|
+ assert.ok(updatedParents.length > 1);
|
|
result = new ArrayPredictionContext(updatedParents, updatedReturnStates);
|
|
}
|
|
if (context.hasEmpty) {
|
|
@@ -569,16 +569,16 @@ ArrayPredictionContext = __decorate([
|
|
let SingletonPredictionContext = class SingletonPredictionContext extends PredictionContext {
|
|
constructor(parent, returnState) {
|
|
super(PredictionContext.calculateSingleHashCode(parent, returnState));
|
|
- // assert(returnState != PredictionContext.EMPTY_FULL_STATE_KEY && returnState != PredictionContext.EMPTY_LOCAL_STATE_KEY);
|
|
+ // assert.ok(returnState != PredictionContext.EMPTY_FULL_STATE_KEY && returnState != PredictionContext.EMPTY_LOCAL_STATE_KEY);
|
|
this.parent = parent;
|
|
this.returnState = returnState;
|
|
}
|
|
getParent(index) {
|
|
- // assert(index == 0);
|
|
+ // assert.ok(index == 0);
|
|
return this.parent;
|
|
}
|
|
getReturnState(index) {
|
|
- // assert(index == 0);
|
|
+ // assert.ok(index == 0);
|
|
return this.returnState;
|
|
}
|
|
findReturnState(returnState) {
|
|
diff --git a/atn/PredictionContextCache.js b/atn/PredictionContextCache.js
|
|
index d919815854f0519b2b602a316f93f702f06c9754..ecd697a2b7141ebf5c76198bb49088cff90c4d35 100644
|
|
--- a/atn/PredictionContextCache.js
|
|
+++ b/atn/PredictionContextCache.js
|
|
@@ -104,8 +104,8 @@ PredictionContextCache.UNCACHED = new PredictionContextCache(false);
|
|
PredictionContextCache.PredictionContextAndInt = PredictionContextAndInt;
|
|
class IdentityCommutativePredictionContextOperands {
|
|
constructor(x, y) {
|
|
- assert(x != null);
|
|
- assert(y != null);
|
|
+ assert.ok(x != null);
|
|
+ assert.ok(y != null);
|
|
this._x = x;
|
|
this._y = y;
|
|
}
|
|
diff --git a/dfa/DFAState.js b/dfa/DFAState.js
|
|
index dcdd796eef9a8046033b233d6cc2ca33b198cb9d..d7a095dcc5680d1af58e6e213ebaed98eae4c1b1 100644
|
|
--- a/dfa/DFAState.js
|
|
+++ b/dfa/DFAState.js
|
|
@@ -66,11 +66,11 @@ class DFAState {
|
|
return this.contextSymbols.get(symbol);
|
|
}
|
|
setContextSymbol(symbol) {
|
|
- assert(this.isContextSensitive);
|
|
+ assert.ok(this.isContextSensitive);
|
|
this.contextSymbols.set(symbol);
|
|
}
|
|
setContextSensitive(atn) {
|
|
- assert(!this.configs.isOutermostConfigSet);
|
|
+ assert.ok(!this.configs.isOutermostConfigSet);
|
|
if (this.isContextSensitive) {
|
|
return;
|
|
}
|
|
diff --git a/misc/Array2DHashSet.js b/misc/Array2DHashSet.js
|
|
index 5e9b5dca143df940562734ce158c532a48fed78d..3796235c05d771f985a3e6d5cd9f5f8116188a5f 100644
|
|
--- a/misc/Array2DHashSet.js
|
|
+++ b/misc/Array2DHashSet.js
|
|
@@ -153,7 +153,7 @@ class Array2DHashSet {
|
|
newBucket.push(o);
|
|
}
|
|
}
|
|
- assert(this.n === oldSize);
|
|
+ assert.ok(this.n === oldSize);
|
|
}
|
|
add(t) {
|
|
let existing = this.getOrAdd(t);
|