refactor(chevrotain): set noImplicitAny: true and fix errors

examples/parser/parametrized_rules/parametrized.js

@@ -110,11 +110,7 @@ module.exports = function (text, mood) {
   // setting a new input will RESET the parser instance's state.
   parser.input = lexResult.tokens
 
-  // Passing the argument to the top rule.
-  // note that because we are invoking a "start rule" we must provide the arguments as the second parameter.
-  // with the first parameter provided the value <1>
-  // also note that the arguments are passed as an array
-  const cst = parser.topRule(1, [mood])
+  const cst = parser.topRule(mood)
 
   return {
     cst: cst,

packages/chevrotain/src/lang/lang_extensions.ts

@@ -1,6 +1,6 @@
 const NAME = "name"
 
-export function defineNameProp(obj, nameValue): void {
+export function defineNameProp(obj: {}, nameValue: string): void {
   Object.defineProperty(obj, NAME, {
     enumerable: false,
     configurable: true,

packages/chevrotain/src/parse/cst/cst_visitor.ts

@@ -10,7 +10,7 @@ import {
   map
 } from "@chevrotain/utils"
 import { defineNameProp } from "../../lang/lang_extensions"
-import { ICstVisitor } from "@chevrotain/types"
+import { CstNode, ICstVisitor } from "@chevrotain/types"
 
 export function defaultVisit<IN, OUT>(ctx: any, param: IN): OUT {
   const childrenNames = keys(ctx)
@@ -45,7 +45,7 @@ export function createBaseSemanticVisitorConstructor(
   defineNameProp(derivedConstructor, grammarName + "BaseSemantics")
 
   const semanticProto = {
-    visit: function (cstNode, param) {
+    visit: function (cstNode: CstNode | CstNode[], param: any) {
       // enables writing more concise visitor methods when CstNode has only a single child
       if (isArray(cstNode)) {
         // A CST Node's children dictionary can never have empty arrays as values
@@ -121,7 +121,7 @@ export interface IVisitorDefinitionError {
 }
 
 export function validateVisitor(
-  visitorInstance: Function,
+  visitorInstance: ICstVisitor<unknown, unknown>,
   ruleNames: string[]
 ): IVisitorDefinitionError[] {
   const missingErrors = validateMissingCstMethods(visitorInstance, ruleNames)
@@ -131,11 +131,11 @@ export function validateVisitor(
 }
 
 export function validateMissingCstMethods(
-  visitorInstance: Function,
+  visitorInstance: ICstVisitor<unknown, unknown>,
   ruleNames: string[]
 ): IVisitorDefinitionError[] {
   const errors: IVisitorDefinitionError[] = map(ruleNames, (currRuleName) => {
-    if (!isFunction(visitorInstance[currRuleName])) {
+    if (!isFunction((visitorInstance as any)[currRuleName])) {
       return {
         msg: `Missing visitor method: <${currRuleName}> on ${<any>(
           visitorInstance.constructor.name
@@ -151,14 +151,14 @@ export function validateMissingCstMethods(
 
 const VALID_PROP_NAMES = ["constructor", "visit", "validateVisitor"]
 export function validateRedundantMethods(
-  visitorInstance: Function,
+  visitorInstance: ICstVisitor<unknown, unknown>,
   ruleNames: string[]
 ): IVisitorDefinitionError[] {
   const errors = []
 
   for (const prop in visitorInstance) {
     if (
-      isFunction(visitorInstance[prop]) &&
+      isFunction((visitorInstance as any)[prop]) &&
       !contains(VALID_PROP_NAMES, prop) &&
       !contains(ruleNames, prop)
     ) {

packages/chevrotain/src/parse/exceptions_public.ts

@@ -30,7 +30,7 @@ abstract class RecognitionException
   implements IRecognitionException
 {
   context: IRecognizerContext
-  resyncedTokens = []
+  resyncedTokens: IToken[] = []
 
   protected constructor(message: string, public token: IToken) {
     super(message)

packages/chevrotain/src/parse/grammar/checks.ts

@@ -1,8 +1,8 @@
 import * as utils from "@chevrotain/utils"
 import {
   contains,
-  every,
   findAll,
+  flatMap,
   flatten,
   forEach,
   isEmpty,
@@ -56,24 +56,24 @@ export function validateGrammar(
   errMsgProvider: IGrammarValidatorErrorMessageProvider,
   grammarName: string
 ): IParserDefinitionError[] {
-  const duplicateErrors: any = utils.map(topLevels, (currTopLevel) =>
+  const duplicateErrors = flatMap(topLevels, (currTopLevel) =>
     validateDuplicateProductions(currTopLevel, errMsgProvider)
   )
-  const leftRecursionErrors: any = utils.map(topLevels, (currTopRule) =>
+  const leftRecursionErrors = flatMap(topLevels, (currTopRule) =>
     validateNoLeftRecursion(currTopRule, currTopRule, errMsgProvider)
   )
 
-  let emptyAltErrors = []
-  let ambiguousAltsErrors = []
-  let emptyRepetitionErrors = []
+  let emptyAltErrors: IParserEmptyAlternativeDefinitionError[] = []
+  let ambiguousAltsErrors: IParserAmbiguousAlternativesDefinitionError[] = []
+  let emptyRepetitionErrors: IParserDefinitionError[] = []
 
   // left recursion could cause infinite loops in the following validations.
   // It is safest to first have the user fix the left recursion errors first and only then examine Further issues.
-  if (every(leftRecursionErrors, isEmpty)) {
-    emptyAltErrors = map(topLevels, (currTopRule) =>
+  if (isEmpty(leftRecursionErrors)) {
+    emptyAltErrors = flatMap(topLevels, (currTopRule) =>
       validateEmptyOrAlternative(currTopRule, errMsgProvider)
     )
-    ambiguousAltsErrors = map(topLevels, (currTopRule) =>
+    ambiguousAltsErrors = flatMap(topLevels, (currTopRule) =>
       validateAmbiguousAlternationAlternatives(
         currTopRule,
         globalMaxLookahead,
@@ -94,11 +94,11 @@ export function validateGrammar(
     errMsgProvider
   )
 
-  const tooManyAltsErrors = map(topLevels, (curRule) =>
+  const tooManyAltsErrors = flatMap(topLevels, (curRule) =>
     validateTooManyAlts(curRule, errMsgProvider)
   )
 
-  const duplicateRulesError = map(topLevels, (curRule) =>
+  const duplicateRulesError = flatMap(topLevels, (curRule) =>
     validateRuleDoesNotAlreadyExist(
       curRule,
       topLevels,
@@ -107,18 +107,14 @@ export function validateGrammar(
     )
   )
 
-  return <any>(
-    utils.flatten(
-      duplicateErrors.concat(
-        emptyRepetitionErrors,
-        leftRecursionErrors,
-        emptyAltErrors,
-        ambiguousAltsErrors,
-        termsNamespaceConflictErrors,
-        tooManyAltsErrors,
-        duplicateRulesError
-      )
-    )
+  return (duplicateErrors as IParserDefinitionError[]).concat(
+    emptyRepetitionErrors,
+    leftRecursionErrors,
+    emptyAltErrors,
+    ambiguousAltsErrors,
+    termsNamespaceConflictErrors,
+    tooManyAltsErrors,
+    duplicateRulesError
   )
 }
 
@@ -223,7 +219,7 @@ export class OccurrenceValidationCollector extends GAstVisitor {
 export function validateRuleDoesNotAlreadyExist(
   rule: Rule,
   allRules: Rule[],
-  className,
+  className: string,
   errMsgProvider: IGrammarValidatorErrorMessageProvider
 ): IParserDefinitionError[] {
   const errors = []
@@ -258,7 +254,7 @@ export function validateRuleDoesNotAlreadyExist(
 export function validateRuleIsOverridden(
   ruleName: string,
   definedRulesNames: string[],
-  className
+  className: string
 ): IParserDefinitionError[] {
   const errors = []
   let errMsg
@@ -283,7 +279,7 @@ export function validateNoLeftRecursion(
   errMsgProvider: IGrammarValidatorErrorMessageProvider,
   path: Rule[] = []
 ): IParserDefinitionError[] {
-  const errors = []
+  const errors: IParserDefinitionError[] = []
   const nextNonTerminals = getFirstNoneTerminal(currRule.definition)
   if (utils.isEmpty(nextNonTerminals)) {
     return []
@@ -307,7 +303,7 @@ export function validateNoLeftRecursion(
       nextNonTerminals,
       path.concat([topRule])
     )
-    const errorsFromNextSteps = utils.map(validNextSteps, (currRefRule) => {
+    const errorsFromNextSteps = flatMap(validNextSteps, (currRefRule) => {
       const newPath = utils.cloneArr(path)
       newPath.push(currRefRule)
       return validateNoLeftRecursion(
@@ -318,12 +314,12 @@ export function validateNoLeftRecursion(
       )
     })
 
-    return errors.concat(utils.flatten(errorsFromNextSteps))
+    return errors.concat(errorsFromNextSteps)
   }
 }
 
 export function getFirstNoneTerminal(definition: IProduction[]): Rule[] {
-  let result = []
+  let result: Rule[] = []
   if (utils.isEmpty(definition)) {
     return result
   }
@@ -367,7 +363,7 @@ export function getFirstNoneTerminal(definition: IProduction[]): Rule[] {
 }
 
 class OrCollector extends GAstVisitor {
-  public alternations = []
+  public alternations: Alternation[] = []
 
   public visitAlternation(node: Alternation): void {
     this.alternations.push(node)
@@ -524,7 +520,7 @@ export function validateSomeNonEmptyLookaheadPath(
   maxLookahead: number,
   errMsgProvider: IGrammarValidatorErrorMessageProvider
 ): IParserDefinitionError[] {
-  const errors = []
+  const errors: IParserDefinitionError[] = []
   forEach(topLevelRules, (currTopRule) => {
     const collectorVisitor = new RepetitionCollector()
     currTopRule.accept(collectorVisitor)
@@ -568,7 +564,7 @@ function checkAlternativesAmbiguities(
   rule: Rule,
   errMsgProvider: IGrammarValidatorErrorMessageProvider
 ): IParserAmbiguousAlternativesDefinitionError[] {
-  const foundAmbiguousPaths = []
+  const foundAmbiguousPaths: Alternative = []
   const identicalAmbiguities = reduce(
     alternatives,
     (result, currAlt, currAltIdx) => {
@@ -636,9 +632,7 @@ export function checkPrefixAlternativesAmbiguities(
   alternation: Alternation,
   rule: Rule,
   errMsgProvider: IGrammarValidatorErrorMessageProvider
-): IAmbiguityDescriptor[] {
-  let errors = []
-
+): IParserAmbiguousAlternativesDefinitionError[] {
   // flatten
   const pathsAndIndices = reduce(
     alternatives,
@@ -648,10 +642,10 @@ export function checkPrefixAlternativesAmbiguities(
       })
       return result.concat(currPathsAndIdx)
     },
-    []
+    [] as { idx: number; path: TokenType[] }[]
   )
 
-  forEach(pathsAndIndices, (currPathAndIdx) => {
+  const errors = flatMap(pathsAndIndices, (currPathAndIdx) => {
     const alternativeGast = alternation.definition[currPathAndIdx.idx]
     // ignore (skip) ambiguities with this alternative
     if (alternativeGast.ignoreAmbiguities === true) {
@@ -678,7 +672,7 @@ export function checkPrefixAlternativesAmbiguities(
 
     const currPathPrefixErrors = map(
       prefixAmbiguitiesPathsAndIndices,
-      (currAmbPathAndIdx) => {
+      (currAmbPathAndIdx): IParserAmbiguousAlternativesDefinitionError => {
         const ambgIndices = [currAmbPathAndIdx.idx + 1, targetIdx + 1]
         const occurrence = alternation.idx === 0 ? "" : alternation.idx
 
@@ -697,7 +691,8 @@ export function checkPrefixAlternativesAmbiguities(
         }
       }
     )
-    errors = errors.concat(currPathPrefixErrors)
+
+    return currPathPrefixErrors
   })
 
   return errors
@@ -708,7 +703,7 @@ function checkTerminalAndNoneTerminalsNameSpace(
   tokenTypes: TokenType[],
   errMsgProvider: IGrammarValidatorErrorMessageProvider
 ): IParserDefinitionError[] {
-  const errors = []
+  const errors: IParserDefinitionError[] = []
 
   const tokenNames = map(tokenTypes, (currToken) => currToken.name)
 

packages/chevrotain/src/parse/grammar/follow.ts

@@ -8,7 +8,7 @@ import { IProduction, TokenType } from "@chevrotain/types"
 // This ResyncFollowsWalker computes all of the follows required for RESYNC
 // (skipping reference production).
 export class ResyncFollowsWalker extends RestWalker {
-  public follows = {}
+  public follows: Record<string, TokenType[]> = {}
 
   constructor(private topProd: Rule) {
     super()

packages/chevrotain/src/parse/grammar/gast/gast.ts

@@ -96,7 +96,15 @@ export function getProductionDslName(prod: IProductionWithOccurrence): string {
 export class DslMethodsCollectorVisitor extends GAstVisitor {
   // A minus is never valid in an identifier name
   public separator = "-"
-  public dslMethods = {
+  public dslMethods: {
+    [subruleOrTerminalName: string]: IProductionWithOccurrence[]
+    option: Option[]
+    alternation: Alternation[]
+    repetition: Repetition[]
+    repetitionWithSeparator: RepetitionWithSeparator[]
+    repetitionMandatory: RepetitionMandatory[]
+    repetitionMandatoryWithSeparator: RepetitionMandatoryWithSeparator[]
+  } = {
     option: [],
     alternation: [],
     repetition: [],

packages/chevrotain/src/parse/grammar/gast/gast_resolver_public.ts

@@ -23,7 +23,7 @@ export function resolveGrammar(options: {
     errMsgProvider: defaultGrammarResolverErrorProvider
   })
 
-  const topRulesTable = {}
+  const topRulesTable: { [ruleName: string]: Rule } = {}
   forEach(options.rules, (rule) => {
     topRulesTable[rule.name] = rule
   })

packages/chevrotain/src/parse/grammar/interpreter.ts

@@ -147,7 +147,11 @@ export interface IFirstAfterRepetition {
  * it never "follows" production refs
  */
 export class AbstractNextTerminalAfterProductionWalker extends RestWalker {
-  protected result = {
+  protected result: {
+    token: TokenType | undefined
+    occurrence: number | undefined
+    isEndOfRule: boolean | undefined
+  } = {
     token: undefined,
     occurrence: undefined,
     isEndOfRule: undefined
@@ -250,11 +254,11 @@ export interface PartialPathAndSuffixes {
 export function possiblePathsFrom(
   targetDef: IProduction[],
   maxLength: number,
-  currPath = []
+  currPath: TokenType[] = []
 ): PartialPathAndSuffixes[] {
   // avoid side effects
   currPath = cloneArr(currPath)
-  let result = []
+  let result: PartialPathAndSuffixes[] = []
   let i = 0
 
   // TODO: avoid inner funcs