From 61410a96d8c0e582a10e5ba339946482288c9b90 Mon Sep 17 00:00:00 2001 From: Peter van Gulik Date: Wed, 27 Mar 2024 21:56:02 +0100 Subject: [PATCH] APEX Parsing Support (#421) * feat: add support for APEX parsing and lexing using antlr4ng * feat: support test impacting in CLI --- .gitignore | 2 + .vscode/tasks.json | 21 +- package.json | 18 +- packages/apex/README.md | 89 + packages/apex/grammar/ApexLexer.g4 | 457 + packages/apex/grammar/ApexParser.g4 | 1210 + packages/apex/jest.config.js | 12 + packages/apex/package.json | 73 + .../apex/src/__tests__/blockVistor.test.ts | 54 + packages/apex/src/__tests__/parser.test.ts | 358 + .../src/__tests__/testIndentifier.test.ts | 49 + packages/apex/src/grammar/ApexLexer.ts | 1436 ++ packages/apex/src/grammar/ApexParser.ts | 19537 ++++++++++++++++ .../apex/src/grammar/ApexParserListener.ts | 1997 ++ .../apex/src/grammar/ApexParserVisitor.ts | 1269 + packages/apex/src/grammar/index.ts | 4 + packages/apex/src/index.ts | 3 + packages/apex/src/parser.ts | 81 + packages/apex/src/standardNamespace.json | 46 + packages/apex/src/streams.ts | 149 + packages/apex/src/testIndentifier.ts | 195 + packages/apex/src/types.ts | 191 + packages/apex/src/visitors/blockVisitor.ts | 137 + .../src/visitors/classDeclarationVisitor.ts | 168 + .../src/visitors/compilationUnitVisitor.ts | 35 + .../apex/src/visitors/declarationVisitor.ts | 61 + .../src/visitors/fieldDeclarationVisitor.ts | 59 + .../src/visitors/formalParameterVisitor.ts | 27 + .../src/visitors/methodDeclarationVisitor.ts | 71 + .../visitors/propertyDeclarationVisitor.ts | 86 + .../apex/src/visitors/syntaxTreeVisitor.ts | 62 + packages/apex/src/visitors/typeListVisitor.ts | 15 + .../apex/src/visitors/typeRefCollector.ts | 59 + packages/apex/src/visitors/typeRefVisitor.ts | 22 + packages/apex/tsconfig.json | 13 + packages/cli/package.json | 3 +- packages/cli/src/commands/impactedTests.ts | 135 + packages/cli/src/index.ts | 8 +- packages/cli/tsconfig.json | 1 + packages/salesforce/package.json | 4 +- packages/util/src/__tests__/deferred.test.ts | 62 + packages/util/src/__tests__/timedMap.test.ts | 133 + packages/util/src/index.ts | 1 + packages/util/src/timedMap.ts | 173 + .../src/commands/apex/toggleTestCoverage.ts | 2 +- pnpm-lock.yaml | 1237 +- tsconfig.json | 2 + 47 files changed, 29518 insertions(+), 309 deletions(-) create mode 100644 packages/apex/README.md create mode 100644 packages/apex/grammar/ApexLexer.g4 create mode 100644 packages/apex/grammar/ApexParser.g4 create mode 100644 packages/apex/jest.config.js create mode 100644 packages/apex/package.json create mode 100644 packages/apex/src/__tests__/blockVistor.test.ts create mode 100644 packages/apex/src/__tests__/parser.test.ts create mode 100644 packages/apex/src/__tests__/testIndentifier.test.ts create mode 100644 packages/apex/src/grammar/ApexLexer.ts create mode 100644 packages/apex/src/grammar/ApexParser.ts create mode 100644 packages/apex/src/grammar/ApexParserListener.ts create mode 100644 packages/apex/src/grammar/ApexParserVisitor.ts create mode 100644 packages/apex/src/grammar/index.ts create mode 100644 packages/apex/src/index.ts create mode 100644 packages/apex/src/parser.ts create mode 100644 packages/apex/src/standardNamespace.json create mode 100644 packages/apex/src/streams.ts create mode 100644 packages/apex/src/testIndentifier.ts create mode 100644 packages/apex/src/types.ts create mode 100644 packages/apex/src/visitors/blockVisitor.ts create mode 100644 packages/apex/src/visitors/classDeclarationVisitor.ts create mode 100644 packages/apex/src/visitors/compilationUnitVisitor.ts create mode 100644 packages/apex/src/visitors/declarationVisitor.ts create mode 100644 packages/apex/src/visitors/fieldDeclarationVisitor.ts create mode 100644 packages/apex/src/visitors/formalParameterVisitor.ts create mode 100644 packages/apex/src/visitors/methodDeclarationVisitor.ts create mode 100644 packages/apex/src/visitors/propertyDeclarationVisitor.ts create mode 100644 packages/apex/src/visitors/syntaxTreeVisitor.ts create mode 100644 packages/apex/src/visitors/typeListVisitor.ts create mode 100644 packages/apex/src/visitors/typeRefCollector.ts create mode 100644 packages/apex/src/visitors/typeRefVisitor.ts create mode 100644 packages/apex/tsconfig.json create mode 100644 packages/cli/src/commands/impactedTests.ts create mode 100644 packages/util/src/__tests__/deferred.test.ts create mode 100644 packages/util/src/__tests__/timedMap.test.ts create mode 100644 packages/util/src/timedMap.ts diff --git a/.gitignore b/.gitignore index 048bdbe3..287dcf33 100644 --- a/.gitignore +++ b/.gitignore @@ -14,3 +14,5 @@ packages/*/lib *.tsbuildinfo /docs /packages/*/coverage +/packages/apex/src/grammar/*.interp +/packages/apex/src/grammar/*.tokens diff --git a/.vscode/tasks.json b/.vscode/tasks.json index d78bcb69..cde49ac0 100644 --- a/.vscode/tasks.json +++ b/.vscode/tasks.json @@ -92,7 +92,7 @@ "group": { "kind": "build" }, - "dependsOn": ["watch-vlocity-deploy"] + "dependsOn": ["watch-vlocity-deploy", "watch-apex"] }, { "label": "watch-vlocity-deploy", @@ -160,7 +160,24 @@ "group": { "kind": "build" }, - "dependsOn": ["watch-core"] + "dependsOn": ["watch-util", "watch-core"] + }, + { + "label": "watch-apex", + "type": "shell", + "problemMatcher": { + "base": "$tsc-watch", + "fileLocation": ["relative", "${workspaceFolder}/packages/vlocity-apex"] + }, + "command": "pnpm --filter @vlocode/apex watch", + "isBackground": true, + "presentation": { + "reveal": "always" + }, + "group": { + "kind": "build" + }, + "dependsOn": ["watch-util", "watch-core"] }, { "label": "watch-core", diff --git a/package.json b/package.json index 8a014089..695d4073 100644 --- a/package.json +++ b/package.json @@ -1,7 +1,7 @@ { "private": true, "name": "vlocode-project", - "packageManager": "pnpm@8.12.1", + "packageManager": "pnpm@8.15.4+sha256.cea6d0bdf2de3a0549582da3983c70c92ffc577ff4410cbf190817ddc35137c2", "description": "Vlocode project packages", "version": "0.21.6", "license": "MIT", @@ -24,15 +24,15 @@ "@types/fs-extra": "^11", "@types/jest": "^29.5.11", "@types/node": "^20", - "@typescript-eslint/eslint-plugin": "^5.30.5", - "@typescript-eslint/parser": "^5.30.5", + "@typescript-eslint/eslint-plugin": "^5.62.0", + "@typescript-eslint/parser": "^5.62.0", "chalk": "^4.1.2", - "eslint": "^8.19.0", - "eslint-config-prettier": "^8.3.0", - "eslint-plugin-import": "^2.25.4", - "eslint-plugin-jsdoc": "^37.6.1", + "eslint": "^8.57.0", + "eslint-config-prettier": "^8.10.0", + "eslint-plugin-import": "^2.29.1", + "eslint-plugin-jsdoc": "^37.9.7", "eslint-plugin-prefer-arrow": "^1.2.3", - "eslint-plugin-prettier": "^4.0.0", + "eslint-plugin-prettier": "^4.2.1", "fs-extra": "^11", "husky": "^8.0.1", "jest": "^29.7.0", @@ -75,7 +75,7 @@ "sync-ws-version": "node -e \"fs.writeFileSync('./package.json', JSON.stringify({ ...require('./package.json'), version: require('./lerna.json').version }, undefined, 4));\"", "test": "jest", "prepare": "husky install", - "lint": "eslint ./packages/*/src/**/*.ts --ext .ts", + "lint": "eslint ./packages/*/src --no-error-on-unmatched-pattern --ext .ts", "docs": "pnpm sync-ws-version && typedoc" }, "resolutions": { diff --git a/packages/apex/README.md b/packages/apex/README.md new file mode 100644 index 00000000..ca2e37c8 --- /dev/null +++ b/packages/apex/README.md @@ -0,0 +1,89 @@ +[![CircleCI](https://circleci.com/gh/Codeneos/vlocode/tree/main.svg?style=svg)](https://circleci.com/gh/Codeneos/vlocode/tree/main) +[![GitHub top language](https://img.shields.io/github/languages/top/codeneos/vlocode.svg?logo=github)](https://github.com/Codeneos/vlocode) +[![Bugs](https://img.shields.io/sonar/https/sonarcloud.io/curlybracket.vlocode/bugs.svg?color=lightgray&label=bugs&logo=data%3Aimage%2Fpng%3Bbase64%2CiVBORw0KGgoAAAANSUhEUgAAAEAAAABACAMAAACdt4HsAAAAolBMVEUAAAD%2FZgD%2FZgD%2FZgD%2FZgD%2FZgD%2FZgD%2FZgD%2FZgD%2FZgD%2FZgD%2FZgD%2FZgD%2FZgD%2FZgD%2FZgD%2FZgD%2FZgD%2FZgD%2FZgD%2FZgD%2FZgD%2FZgD%2FZgD%2FZgD%2FZgD%2FZgD%2FZgD%2FZgD%2FZgD%2FZgD%2FZgD%2FZgD%2FZgD%2FZgD%2FZgD%2FZgD%2FZgD%2FZgD%2FZgD%2FZgD%2FZgD%2FZgD%2FZgD%2FZgD%2FZgD%2FZgD%2FZgD%2FZgD%2FZgD%2FZgD%2FZgD%2FZgD%2FZgCXdjhZAAAANXRSTlMA%2Bg335ykFAwnr7hDZON7Ie1ZDMfTUmIUUSSLPoVAa4r6K8rtyXD62gG2xpsKSjnZpYx6qTp5XIo8AAAOWSURBVFjD7VbZtqIwEGSVRXYQAVFBFvf16v%2F%2F2tgJKsYEvPM4Z%2FLiwV7SXV2phPu3lyB71fnserLwN9HD%2BGBL4u2%2BRMk%2BeMJvw887CH6uIKuGvwhXvIK%2FEYtf1sq38epRu1GWtFa%2FLH%2FPNxFFvq6q9aGQ8LeYC19hH2L30VFWm4p8Z4Tb2H%2BRYbBC%2B2urWfvfy1hHGZx%2BHNwFeBox4alMDfhfv%2FbFJxNUvvlpqVEGe9aTYAxe85pmihGWTne8bEGnJ7qx5KG5pDNBCZssBcZ8M7CeOkcILuKUCTAP6bvo5GuAE5P1ESAsyR0JKqhxzLYfACG3ZwY8dMDsoWcOKXDFZ9tNYFnYQeMNkPh09fzZgD5loMKWfYxrREOeF3VjU%2FqUHMn8bp8w5Elwl4tba2nbTwWRNSRPBUWeFHMjkgqirckMXuPDFx5hUtcSGU4b%2BemV3BHeSHpoUut2uirL8XYSwNfCJEDetjQyjFrtNyJmjE3cnBJ54b3dgmhVBgytfIRTpENChPQ8aYNSHxzy4DkoTrmMseju1XcRmg64L866eL0nj1ER4rkZ7oghQuScgadNWz5ijIVBzlkiRCDoQKOB25Dagqhw8ECGP%2FXGHwOEwKPvCj4184HMpk%2Fwo72IGpWfzEEjze8WGwqL%2BwrIMbNafrUO52LGefCb9RUwtFG82ybvBnaecsd%2BrQYEfgD0d6lZ4x6gFdGj3%2FLDV2H%2B0tr4FHVZcjaUllDnvppk8etrRqrxzAJUOQNIGLEEcHTpwAVpNIfSRCyFDcwOZu6ACbgC6o25Quj0VrAjhINAuWInuGAMUtiHyqMp333L1AFQmCuZbr7WSTHMoBVngpsd0UCCCetm50W88DihgB5c5mNjz0oQB3hnjNWOVoKpA8Amo4Dl4wwkBupFoR4AgGnIfq7M5ScYOq0JD9jO5wPmgwmDH%2B2Qpk0%2FKyjxa32lfsYjRZtcmo0kfJERE4vyoHnihgRT1TOK0J97ngLk92MOWk5XKKxZtiu0CvNTXNlReQmu2FzIbgLlKoJ8XuLtdQ0XUZxkAfzVyzSV8N02Vtvd6s2NN8%2FSMNzaEo%2B%2F525sPG5a%2BycM08xqLAtHfX8Kj26UlZmgRTzFYlTkbJK9RjrNHUSvYWmQFj2UKbQxQ6u1Fz8ay8ojuTMR24nTekAX0aQKd5am65KRHaZvo4vivDAkfaFZdnhOKOEt7ZR9XwYBJZeKLJf7LP4vYv0BK5jBy9A2z3IAAAAASUVORK5CYII%3D)](https://sonarcloud.io/dashboard?id=curlybracket.vlocode) +[![Vulnerabilities](https://img.shields.io/sonar/https/sonarcloud.io/curlybracket.vlocode/vulnerabilities.svg?label=vulnerabilities&logo=data%3Aimage%2Fpng%3Bbase64%2CiVBORw0KGgoAAAANSUhEUgAAAEAAAABACAMAAACdt4HsAAAAolBMVEUAAAD%2FZgD%2FZgD%2FZgD%2FZgD%2FZgD%2FZgD%2FZgD%2FZgD%2FZgD%2FZgD%2FZgD%2FZgD%2FZgD%2FZgD%2FZgD%2FZgD%2FZgD%2FZgD%2FZgD%2FZgD%2FZgD%2FZgD%2FZgD%2FZgD%2FZgD%2FZgD%2FZgD%2FZgD%2FZgD%2FZgD%2FZgD%2FZgD%2FZgD%2FZgD%2FZgD%2FZgD%2FZgD%2FZgD%2FZgD%2FZgD%2FZgD%2FZgD%2FZgD%2FZgD%2FZgD%2FZgD%2FZgD%2FZgD%2FZgD%2FZgD%2FZgD%2FZgD%2FZgCXdjhZAAAANXRSTlMA%2Bg335ykFAwnr7hDZON7Ie1ZDMfTUmIUUSSLPoVAa4r6K8rtyXD62gG2xpsKSjnZpYx6qTp5XIo8AAAOWSURBVFjD7VbZtqIwEGSVRXYQAVFBFvf16v%2F%2F2tgJKsYEvPM4Z%2FLiwV7SXV2phPu3lyB71fnserLwN9HD%2BGBL4u2%2BRMk%2BeMJvw887CH6uIKuGvwhXvIK%2FEYtf1sq38epRu1GWtFa%2FLH%2FPNxFFvq6q9aGQ8LeYC19hH2L30VFWm4p8Z4Tb2H%2BRYbBC%2B2urWfvfy1hHGZx%2BHNwFeBox4alMDfhfv%2FbFJxNUvvlpqVEGe9aTYAxe85pmihGWTne8bEGnJ7qx5KG5pDNBCZssBcZ8M7CeOkcILuKUCTAP6bvo5GuAE5P1ESAsyR0JKqhxzLYfACG3ZwY8dMDsoWcOKXDFZ9tNYFnYQeMNkPh09fzZgD5loMKWfYxrREOeF3VjU%2FqUHMn8bp8w5Elwl4tba2nbTwWRNSRPBUWeFHMjkgqirckMXuPDFx5hUtcSGU4b%2BemV3BHeSHpoUut2uirL8XYSwNfCJEDetjQyjFrtNyJmjE3cnBJ54b3dgmhVBgytfIRTpENChPQ8aYNSHxzy4DkoTrmMseju1XcRmg64L866eL0nj1ER4rkZ7oghQuScgadNWz5ijIVBzlkiRCDoQKOB25Dagqhw8ECGP%2FXGHwOEwKPvCj4184HMpk%2Fwo72IGpWfzEEjze8WGwqL%2BwrIMbNafrUO52LGefCb9RUwtFG82ybvBnaecsd%2BrQYEfgD0d6lZ4x6gFdGj3%2FLDV2H%2B0tr4FHVZcjaUllDnvppk8etrRqrxzAJUOQNIGLEEcHTpwAVpNIfSRCyFDcwOZu6ACbgC6o25Quj0VrAjhINAuWInuGAMUtiHyqMp333L1AFQmCuZbr7WSTHMoBVngpsd0UCCCetm50W88DihgB5c5mNjz0oQB3hnjNWOVoKpA8Amo4Dl4wwkBupFoR4AgGnIfq7M5ScYOq0JD9jO5wPmgwmDH%2B2Qpk0%2FKyjxa32lfsYjRZtcmo0kfJERE4vyoHnihgRT1TOK0J97ngLk92MOWk5XKKxZtiu0CvNTXNlReQmu2FzIbgLlKoJ8XuLtdQ0XUZxkAfzVyzSV8N02Vtvd6s2NN8%2FSMNzaEo%2B%2F525sPG5a%2BycM08xqLAtHfX8Kj26UlZmgRTzFYlTkbJK9RjrNHUSvYWmQFj2UKbQxQ6u1Fz8ay8ojuTMR24nTekAX0aQKd5am65KRHaZvo4vivDAkfaFZdnhOKOEt7ZR9XwYBJZeKLJf7LP4vYv0BK5jBy9A2z3IAAAAASUVORK5CYII%3D)](https://sonarcloud.io/dashboard?id=curlybracket.vlocode) +![NPM Version](https://img.shields.io/npm/v/%40vlocode%5Capex) + +# **@vlocode/apex** Salesforce APEX Language Parser + +Antlr4 based [APEX Parser](./src/grammar/ApexParser.ts) and [Grammar](./grammar/ApexParser.g4). This library uses [antlr4ng](https://github.com/mike-lischke/antlr4ng) as runtime library which is a port of the original antlr4 runtime library to TypeScript. + +The library exposes the APEX Lexer and APEX parser generated from the `.g4` grammar files allowing parsing of APEX source code using Visitor or Listener patterns. + +## Features + +- Full APEX and SOQL grammar support +- Extract code structure from APEX source code +- Identify classes, fields, methods, properties and access modifiers +- Identify which classes are tested by which test classes + +## Example: Identifying test classes for a given class + +Below code demonstrates how to identify which classes are tested by which test classes. And prints the test classes for a given class name. + +```ts +import { TestIdentifier } from '@vlocode/apex'; + +const testIdentifier = container.create(TestIdentifier); +await testIdentifier.loadApexClasses(['path/to/apex/classes']); +const testClasses = testIdentifier.getTestClasses('MyClass'); +console.log(testClasses); +``` + +## Example: Extracting class information from APEX source code + +Below code demonstrates how to extract class information from an APEX source fragment and prints the class name, fields and methods as well as their access modifiers. + +```ts +import { Parser } from '@vlocode/apex'; + +const sourceCode = `public class Person { + private String name; + private Integer age; + + public String nameProperty { + get { return this.name; } + } + + public Integer getAge(Integer arg) { + return this.age; + } + + public Date getBirthDate() { + return Date.now(); + } +}`; + +const parser = new Parser(sourceCode); +const struct = parser.getCodeStructure(); + +for (const classInfo of struct.classes) { + console.log(`Class ${classInfo.name}`); + + console.log(` Fields: ${classInfo.fields.length}`); + classInfo.fields.forEach((field, i) => + console.log(` ${i + 1}) ${field.name} (${field.access})`) + ); + + console.log(` Methods: ${classInfo.methods.length}`); + classInfo.methods.forEach((method, i) => + console.log(` ${i + 1}) ${method.name} (${method.access})`) + ); +} +``` + +Outputs the following: + +```shell +Class Person + Fields: 2 + 1) name (private) + 2) age (private) + Methods: 2 + 2) getAge (public) + 3) getBirthDate (public) +``` + +## Credits + +The grammar files in this library are based on the grammar files from the `apex-parser` NPM library originally maintained by Andrey Gavrikov. The original library is no longer maintained and the grammar files have been updated to work with the latest version of Salesforce and the antlr4ng runtime library. diff --git a/packages/apex/grammar/ApexLexer.g4 b/packages/apex/grammar/ApexLexer.g4 new file mode 100644 index 00000000..454f3780 --- /dev/null +++ b/packages/apex/grammar/ApexLexer.g4 @@ -0,0 +1,457 @@ +/* + [The "BSD licence"] + Copyright (c) 2013 Terence Parr, Sam Harwell + All rights reserved. + + Redistribution and use in source and binary forms, with or without + modification, are permitted provided that the following conditions + are met: + 1. Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. + 2. Redistributions in binary form must reproduce the above copyright + notice, this list of conditions and the following disclaimer in the + documentation and/or other materials provided with the distribution. + 3. The name of the author may not be used to endorse or promote products + derived from this software without specific prior written permission. + + THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +*/ + +/** + * An Apexcode grammar derived from Java 1.7 grammar for ANTLR v4. + * Uses ANTLR v4's left-recursive expression notation. + * + * @maintainer: Andrey Gavrikov + * + * You can test with + * + * $ antlr4 ApexGrammar.g4 + * $ javac *.java + * $ grun Apexcode compilationUnit *.cls + */ +lexer grammar ApexLexer; + +channels { + WHITESPACE_CHANNEL, + COMMENT_CHANNEL +} + +// Keywords +ABSTRACT : 'abstract'; +AFTER : 'after'; +BEFORE : 'before'; +BREAK : 'break'; +CATCH : 'catch'; +CLASS : 'class'; +CONTINUE : 'continue'; +DELETE : 'delete'; +DO : 'do'; +ELSE : 'else'; +ENUM : 'enum'; +EXTENDS : 'extends'; +FINAL : 'final'; +FINALLY : 'finally'; +FOR : 'for'; +GET : 'get'; +GLOBAL : 'global'; +IF : 'if'; +IMPLEMENTS : 'implements'; +INHERITED : 'inherited'; +INSERT : 'insert'; +INSTANCEOF : 'instanceof'; +INTERFACE : 'interface'; +MERGE : 'merge'; +NEW : 'new'; +NULL : 'null'; +ON : 'on'; +OVERRIDE : 'override'; +PRIVATE : 'private'; +PROTECTED : 'protected'; +PUBLIC : 'public'; +RETURN : 'return'; +SYSTEMRUNAS : 'system.runas'; +SET : 'set'; +SHARING : 'sharing'; +STATIC : 'static'; +SUPER : 'super'; +SWITCH : 'switch'; +TESTMETHOD : 'testmethod'; +THIS : 'this'; +THROW : 'throw'; +TRANSIENT : 'transient'; +TRIGGER : 'trigger'; +TRY : 'try'; +UNDELETE : 'undelete'; +UPDATE : 'update'; +UPSERT : 'upsert'; +VIRTUAL : 'virtual'; +VOID : 'void'; +WEBSERVICE : 'webservice'; +WHEN : 'when'; +WHILE : 'while'; +WITH : 'with'; +WITHOUT : 'without'; + +// Apex generic types, Set is defined above for properties +LIST : 'list'; +MAP : 'map'; + +// DML keywords +SYSTEM : 'system'; +USER : 'user'; + +// Soql specific keywords +SELECT : 'select'; +COUNT : 'count'; +FROM : 'from'; +AS : 'as'; +USING : 'using'; +SCOPE : 'scope'; +WHERE : 'where'; +ORDER : 'order'; +BY : 'by'; +LIMIT : 'limit'; +SOQLAND : 'and'; +SOQLOR : 'or'; +NOT : 'not'; +AVG : 'avg'; +COUNT_DISTINCT : 'count_distinct'; +MIN : 'min'; +MAX : 'max'; +SUM : 'sum'; +TYPEOF : 'typeof'; +END : 'end'; +THEN : 'then'; +LIKE : 'like'; +IN : 'in'; +INCLUDES : 'includes'; +EXCLUDES : 'excludes'; +ASC : 'asc'; +DESC : 'desc'; +NULLS : 'nulls'; +FIRST : 'first'; +LAST : 'last'; +GROUP : 'group'; +ALL : 'all'; +ROWS : 'rows'; +VIEW : 'view'; +HAVING : 'having'; +ROLLUP : 'rollup'; +TOLABEL : 'tolabel'; +OFFSET : 'offset'; +DATA : 'data'; +CATEGORY : 'category'; +AT : 'at'; +ABOVE : 'above'; +BELOW : 'below'; +ABOVE_OR_BELOW : 'above_or_below'; +SECURITY_ENFORCED : 'security_enforced'; +SYSTEM_MODE : 'system_mode'; +USER_MODE : 'user_mode'; +REFERENCE : 'reference'; +CUBE : 'cube'; +FORMAT : 'format'; +TRACKING : 'tracking'; +VIEWSTAT : 'viewstat'; +CUSTOM : 'custom'; +STANDARD : 'standard'; +DISTANCE : 'distance'; +GEOLOCATION : 'geolocation'; + +// SOQL Date functions +CALENDAR_MONTH : 'calendar_month'; +CALENDAR_QUARTER : 'calendar_quarter'; +CALENDAR_YEAR : 'calendar_year'; +DAY_IN_MONTH : 'day_in_month'; +DAY_IN_WEEK : 'day_in_week'; +DAY_IN_YEAR : 'day_in_year'; +DAY_ONLY : 'day_only'; +FISCAL_MONTH : 'fiscal_month'; +FISCAL_QUARTER : 'fiscal_quarter'; +FISCAL_YEAR : 'fiscal_year'; +HOUR_IN_DAY : 'hour_in_day'; +WEEK_IN_MONTH : 'week_in_month'; +WEEK_IN_YEAR : 'week_in_year'; +CONVERT_TIMEZONE : 'converttimezone'; + +// SOQL Date formulas +YESTERDAY : 'yesterday'; +TODAY : 'today'; +TOMORROW : 'tomorrow'; +LAST_WEEK : 'last_week'; +THIS_WEEK : 'this_week'; +NEXT_WEEK : 'next_week'; +LAST_MONTH : 'last_month'; +THIS_MONTH : 'this_month'; +NEXT_MONTH : 'next_month'; +LAST_90_DAYS : 'last_90_days'; +NEXT_90_DAYS : 'next_90_days'; +LAST_N_DAYS_N : 'last_n_days'; +NEXT_N_DAYS_N : 'next_n_days'; +N_DAYS_AGO_N : 'n_days_ago'; +NEXT_N_WEEKS_N : 'next_n_weeks'; +LAST_N_WEEKS_N : 'last_n_weeks'; +N_WEEKS_AGO_N : 'n_weeks_ago'; +NEXT_N_MONTHS_N : 'next_n_months'; +LAST_N_MONTHS_N : 'last_n_months'; +N_MONTHS_AGO_N : 'n_months_ago'; +THIS_QUARTER : 'this_quarter'; +LAST_QUARTER : 'last_quarter'; +NEXT_QUARTER : 'next_quarter'; +NEXT_N_QUARTERS_N : 'next_n_quarters'; +LAST_N_QUARTERS_N : 'last_n_quarters'; +N_QUARTERS_AGO_N : 'n_quarters_ago'; +THIS_YEAR : 'this_year'; +LAST_YEAR : 'last_year'; +NEXT_YEAR : 'next_year'; +NEXT_N_YEARS_N : 'next_n_years'; +LAST_N_YEARS_N : 'last_n_years'; +N_YEARS_AGO_N : 'n_years_ago'; +THIS_FISCAL_QUARTER : 'this_fiscal_quarter'; +LAST_FISCAL_QUARTER : 'last_fiscal_quarter'; +NEXT_FISCAL_QUARTER : 'next_fiscal_quarter'; +NEXT_N_FISCAL_QUARTERS_N : 'next_n_fiscal_quarters'; +LAST_N_FISCAL_QUARTERS_N : 'last_n_fiscal_quarters'; +N_FISCAL_QUARTERS_AGO_N : 'n_fiscal_quarters_ago'; +THIS_FISCAL_YEAR : 'this_fiscal_year'; +LAST_FISCAL_YEAR : 'last_fiscal_year'; +NEXT_FISCAL_YEAR : 'next_fiscal_year'; +NEXT_N_FISCAL_YEARS_N : 'next_n_fiscal_years'; +LAST_N_FISCAL_YEARS_N : 'last_n_fiscal_years'; +N_FISCAL_YEARS_AGO_N : 'n_fiscal_years_ago'; + +// SOQL Date literal +DateLiteral: Digit Digit Digit Digit '-' Digit Digit '-' Digit Digit; +DateTimeLiteral: DateLiteral 't' Digit Digit ':' Digit Digit ':' Digit Digit ('z' | (('+' | '-') Digit+ ( ':' Digit+)? )); + +// SOQL Currency literal +// (NOTE: this is also a valid Identifier) +IntegralCurrencyLiteral: [a-z] [a-z] [a-z] Digit+; + +// SOSL Keywords +FIND : 'find'; +EMAIL : 'email'; +NAME : 'name'; +PHONE : 'phone'; +SIDEBAR : 'sidebar'; +FIELDS : 'fields'; +METADATA : 'metadata'; +PRICEBOOKID : 'pricebookid'; +NETWORK : 'network'; +SNIPPET : 'snippet'; +TARGET_LENGTH : 'target_length'; +DIVISION : 'division'; +RETURNING : 'returning'; +LISTVIEW : 'listview'; + +FindLiteral + : '[' WS? 'find' WS '\'' FindCharacters? '\'' + ; + +fragment +FindCharacters + : FindCharacter+ + ; + +fragment +FindCharacter + : ~['\\] + | FindEscapeSequence + ; + +FindLiteralAlt + : '[' WS? 'find' WS '{' FindCharactersAlt? '}' + ; + +fragment +FindCharactersAlt + : FindCharacterAlt+ + ; + +fragment +FindCharacterAlt + : ~[}\\] + | FindEscapeSequence + ; + +fragment +FindEscapeSequence + : '\\' [+\-&|!(){}^"~*?:'\\] + ; + +// §3.10.1 Integer Literals + +IntegerLiteral + : Digit Digit* + ; + +LongLiteral + : Digit Digit* [lL] + ; + +NumberLiteral + : Digit* '.' Digit Digit* [dD]? + ; + +fragment +HexCharacter + : Digit | 'a' | 'b' | 'c' | 'd' | 'e' | 'f' + ; + +fragment +Digit + : [0-9] + ; + +// §3.10.3 Boolean Literals + +BooleanLiteral + : 'true' + | 'false' + ; + +// §3.10.5 String Literals + +StringLiteral + : '\'' StringCharacters? '\'' + ; + +fragment +StringCharacters + : StringCharacter+ + ; + +fragment +StringCharacter + : ~['\\] + | EscapeSequence + ; + +// §3.10.6 Escape Sequences for Character and String Literals + +fragment +EscapeSequence + : '\\' [btnfr"'\\] + | '\\u' HexCharacter HexCharacter HexCharacter HexCharacter + ; + +// §3.10.7 The Null Literal + +NullLiteral + : NULL + ; + + +// §3.11 Separators + +LPAREN : '('; +RPAREN : ')'; +LBRACE : '{'; +RBRACE : '}'; +LBRACK : '['; +RBRACK : ']'; +SEMI : ';'; +COMMA : ','; +DOT : '.'; + +// §3.12 Operators + +ASSIGN : '='; +GT : '>'; +LT : '<'; +BANG : '!'; +TILDE : '~'; +QUESTIONDOT : '?.'; +QUESTION : '?'; +DOUBLEQUESTION : '??'; +COLON : ':'; +EQUAL : '=='; +TRIPLEEQUAL : '==='; +NOTEQUAL : '!='; +LESSANDGREATER : '<>'; +TRIPLENOTEQUAL : '!=='; +AND : '&&'; +OR : '||'; +INC : '++'; +DEC : '--'; +ADD : '+'; +SUB : '-'; +MUL : '*'; +DIV : '/'; +BITAND : '&'; +BITOR : '|'; +CARET : '^'; +MAPTO : '=>'; + +ADD_ASSIGN : '+='; +SUB_ASSIGN : '-='; +MUL_ASSIGN : '*='; +DIV_ASSIGN : '/='; +AND_ASSIGN : '&='; +OR_ASSIGN : '|='; +XOR_ASSIGN : '^='; +LSHIFT_ASSIGN : '<<='; +RSHIFT_ASSIGN : '>>='; +URSHIFT_ASSIGN : '>>>='; + +// +// Additional symbols not defined in the lexical specification +// + +ATSIGN : '@'; + + +// §3.8 Identifiers (must appear after all keywords in the grammar) + +Identifier + : JavaLetter JavaLetterOrDigit* + ; + +// Apex identifiers don't support non-ascii but we maintain Java rules here and post-validate +// so we can give better error messages +fragment +JavaLetter + : [a-zA-Z$_] // these are the "java letters" below 0xFF + | // covers all characters above 0xFF which are not a surrogate + ~[\u0000-\u00FF\uD800-\uDBFF] + | // covers UTF-16 surrogate pairs encodings for U+10000 to U+10FFFF + [\uD800-\uDBFF] [\uDC00-\uDFFF] + ; + +fragment +JavaLetterOrDigit + : [a-zA-Z0-9$_] // these are the "java letters or digits" below 0xFF + | // covers all characters above 0xFF which are not a surrogate + ~[\u0000-\u00FF\uD800-\uDBFF] + | // covers UTF-16 surrogate pairs encodings for U+10000 to U+10FFFF + [\uD800-\uDBFF] [\uDC00-\uDFFF] + ; + +// +// Whitespace and comments +// + +WS : [ \t\r\n\u000C]+ -> channel(WHITESPACE_CHANNEL) + ; + +DOC_COMMENT + : '/**' .*? '*/' -> channel(COMMENT_CHANNEL) + ; + +COMMENT + : '/*' .*? '*/' -> channel(COMMENT_CHANNEL) + ; + +LINE_COMMENT + : '//' ~[\r\n]* -> channel(COMMENT_CHANNEL) + ; + diff --git a/packages/apex/grammar/ApexParser.g4 b/packages/apex/grammar/ApexParser.g4 new file mode 100644 index 00000000..f6800639 --- /dev/null +++ b/packages/apex/grammar/ApexParser.g4 @@ -0,0 +1,1210 @@ +/* + [The "BSD licence"] + Copyright (c) 2013 Terence Parr, Sam Harwell + All rights reserved. + + Redistribution and use in source and binary forms, with or without + modification, are permitted provided that the following conditions + are met: + 1. Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. + 2. Redistributions in binary form must reproduce the above copyright + notice, this list of conditions and the following disclaimer in the + documentation and/or other materials provided with the distribution. + 3. The name of the author may not be used to endorse or promote products + derived from this software without specific prior written permission. + + THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +*/ + +/** + * An Apexcode grammar derived from Java 1.7 grammar for ANTLR v4. + * Uses ANTLR v4's left-recursive expression notation. + * + * @maintainer: Andrey Gavrikov + * + * You can test with + * + * $ antlr4 ApexGrammar.g4 + * $ javac *.java + * $ grun Apexcode compilationUnit *.cls + */ +parser grammar ApexParser; +options {tokenVocab=ApexLexer;} + +// entry point for Apex trigger files +triggerUnit + : TRIGGER id ON object=id LPAREN triggerCase (COMMA triggerCase)* RPAREN block EOF + ; + +triggerCase + : when=(BEFORE|AFTER) operation=(INSERT|UPDATE|DELETE|UNDELETE) + ; + +// entry point for Apex class files +compilationUnit + : typeDeclaration* EOF + ; + +typeDeclaration + : modifier* classDeclaration + | modifier* enumDeclaration + | modifier* interfaceDeclaration + ; + +classDeclaration + : CLASS id + (EXTENDS typeRef)? + (IMPLEMENTS typeList)? + classBody + ; + +enumDeclaration + : ENUM id + LBRACE enumConstants? RBRACE + ; + +enumConstants + : id (COMMA id)* + ; + +interfaceDeclaration + : INTERFACE id (EXTENDS typeList)? interfaceBody + ; + +typeList + : typeRef (COMMA typeRef)* + ; + +classBody + : LBRACE classBodyDeclaration* RBRACE + ; + +interfaceBody + : LBRACE interfaceMethodDeclaration* RBRACE + ; + +classBodyDeclaration + : SEMI + | STATIC? block + | modifier* memberDeclaration + ; + +/* Unify all annotation & modifiers so we can give better error messages */ +modifier + : annotation + | GLOBAL + | PUBLIC + | PROTECTED + | PRIVATE + | TRANSIENT + | STATIC + | ABSTRACT + | FINAL + | WEBSERVICE + | OVERRIDE + | VIRTUAL + | TESTMETHOD + | WITH SHARING + | WITHOUT SHARING + | INHERITED SHARING + ; + +memberDeclaration + : methodDeclaration + | fieldDeclaration + | constructorDeclaration + | interfaceDeclaration + | classDeclaration + | enumDeclaration + | propertyDeclaration + ; + + +/* We use rule this even for void methods which cannot have [] after parameters. + This simplifies grammar and we can consider void to be a type, which + renders the [] matching as a context-sensitive issue or a semantic check + for invalid return type after parsing. + */ + + +methodDeclaration + : (typeRef|VOID) id formalParameters + ( block + | SEMI + ) + ; + +constructorDeclaration + : qualifiedName formalParameters block + ; + +fieldDeclaration + : typeRef variableDeclarators SEMI + ; + +propertyDeclaration + : typeRef id LBRACE propertyBlock* RBRACE + ; + +interfaceMethodDeclaration + : modifier* (typeRef|VOID) id formalParameters SEMI + ; + +variableDeclarators + : variableDeclarator (COMMA variableDeclarator)* + ; + +variableDeclarator + : id (ASSIGN expression)? + ; + +arrayInitializer + : LBRACE (expression (COMMA expression)* (COMMA)? )? RBRACE + ; + +typeRef + : typeName (DOT typeName)* arraySubscripts + ; + +arraySubscripts + : (LBRACK RBRACK)* + ; + +typeName + : LIST typeArguments? + | SET typeArguments? + | MAP typeArguments? + | id typeArguments? + ; + +typeArguments + : LT typeList GT + ; + +formalParameters + : LPAREN formalParameterList? RPAREN + ; + +formalParameterList + : formalParameter (COMMA formalParameter)* + ; + +formalParameter + : modifier* typeRef id + ; + +qualifiedName + : id (DOT id)* + ; + +literal + : IntegerLiteral + | LongLiteral + | NumberLiteral + | StringLiteral + | BooleanLiteral + | NULL + ; + +// ANNOTATIONS + +annotation + : ATSIGN qualifiedName ( LPAREN ( elementValuePairs | elementValue )? RPAREN )? + ; + +elementValuePairs + : elementValuePair (COMMA? elementValuePair)* + ; + +elementValuePair + : id ASSIGN elementValue + ; + +elementValue + : expression + | annotation + | elementValueArrayInitializer + ; + +elementValueArrayInitializer + : LBRACE (elementValue (COMMA elementValue)*)? (COMMA)? RBRACE + ; + + +// STATEMENTS / BLOCKS + +block + : LBRACE statement* RBRACE + ; + +localVariableDeclarationStatement + : localVariableDeclaration SEMI + ; + +localVariableDeclaration + : modifier* typeRef variableDeclarators + ; + +statement + : block + | ifStatement + | switchStatement + | forStatement + | whileStatement + | doWhileStatement + | tryStatement + | returnStatement + | throwStatement + | breakStatement + | continueStatement + | insertStatement + | updateStatement + | deleteStatement + | undeleteStatement + | upsertStatement + | mergeStatement + | runAsStatement + | localVariableDeclarationStatement + | expressionStatement + ; + +ifStatement + : IF parExpression statement (ELSE statement)? + ; + +switchStatement + : SWITCH ON expression LBRACE whenControl+ RBRACE + ; + +whenControl + : WHEN whenValue block + ; + +whenValue + : ELSE + | whenLiteral (COMMA whenLiteral)* + | id id + ; + +whenLiteral + : (SUB)? IntegerLiteral + | LongLiteral + | StringLiteral + | NULL + | id + // Salesforce tolerates paren pairs around each literal, + // although this is not explicitly documented. + | LPAREN whenLiteral RPAREN + ; + +forStatement + : FOR LPAREN forControl RPAREN (statement | SEMI) + ; + +whileStatement + : WHILE parExpression (statement | SEMI) + ; + +doWhileStatement + : DO statement WHILE parExpression SEMI + ; + +tryStatement + : TRY block (catchClause+ finallyBlock? | finallyBlock) + ; + +returnStatement + : RETURN expression? SEMI + ; + +throwStatement + : THROW expression SEMI + ; + +breakStatement + : BREAK SEMI + ; + +continueStatement + : CONTINUE SEMI + ; + +accessLevel + : AS (SYSTEM | USER) + ; + +insertStatement + : INSERT accessLevel? expression SEMI + ; + +updateStatement + : UPDATE accessLevel? expression SEMI + ; + +deleteStatement + : DELETE accessLevel? expression SEMI + ; + +undeleteStatement + : UNDELETE accessLevel? expression SEMI + ; + +upsertStatement + : UPSERT accessLevel? expression qualifiedName? SEMI + ; + +mergeStatement + : MERGE accessLevel? expression expression SEMI + ; + +runAsStatement + : SYSTEMRUNAS LPAREN expressionList? RPAREN block + ; + +expressionStatement + : expression SEMI + ; + +propertyBlock + : modifier* (getter | setter) + ; + +getter + : GET (SEMI | block) + ; + +setter + : SET (SEMI | block) + ; + +catchClause + : CATCH LPAREN modifier* qualifiedName id RPAREN block + ; + +finallyBlock + : FINALLY block + ; + +forControl + : enhancedForControl + | forInit? SEMI expression? SEMI forUpdate? + ; + +forInit + : localVariableDeclaration + | expressionList + ; + +enhancedForControl + : typeRef id COLON expression + ; + +forUpdate + : expressionList + ; + +// EXPRESSIONS + +parExpression + : LPAREN expression RPAREN + ; + +expressionList + : expression (COMMA expression)* + ; + +expression + : primary # primaryExpression + | expression (DOT | QUESTIONDOT) + ( dotMethodCall + | anyId + ) # dotExpression + | expression LBRACK expression RBRACK # arrayExpression + | methodCall # methodCallExpression + | NEW creator # newExpression + | LPAREN typeRef RPAREN expression # castExpression + | LPAREN expression RPAREN # subExpression + | expression (INC | DEC) # postOpExpression + | (ADD|SUB|INC|DEC) expression # preOpExpression + | (TILDE|BANG) expression # negExpression + | expression (MUL|DIV) expression # arth1Expression + | expression (ADD|SUB) expression # arth2Expression + | expression (LT LT | GT GT GT | GT GT) expression # bitExpression + | expression (GT | LT) ASSIGN? expression # cmpExpression + | expression INSTANCEOF typeRef # instanceOfExpression + | expression (TRIPLEEQUAL | TRIPLENOTEQUAL | EQUAL | NOTEQUAL | LESSANDGREATER ) expression # equalityExpression + | expression BITAND expression # bitAndExpression + | expression CARET expression # bitNotExpression + | expression BITOR expression # bitOrExpression + | expression AND expression # logAndExpression + | expression OR expression # logOrExpression + | expression QUESTION expression COLON expression # condExpression + | expression DOUBLEQUESTION expression # coalescingExpression + | expression + ( ASSIGN + | ADD_ASSIGN + | SUB_ASSIGN + | MUL_ASSIGN + | DIV_ASSIGN + | AND_ASSIGN + | OR_ASSIGN + | XOR_ASSIGN + | RSHIFT_ASSIGN + | URSHIFT_ASSIGN + | LSHIFT_ASSIGN + ) + expression # assignExpression + ; + +primary + : THIS # thisPrimary + | SUPER # superPrimary + | literal # literalPrimary + | typeRef DOT CLASS # typeRefPrimary + | VOID DOT CLASS # voidPrimary + | id # idPrimary + | soqlLiteral # soqlPrimary + | soslLiteral # soslPrimary + ; + +methodCall + : id LPAREN expressionList? RPAREN + | THIS LPAREN expressionList? RPAREN + | SUPER LPAREN expressionList? RPAREN + ; + +dotMethodCall + : anyId LPAREN expressionList? RPAREN + ; + +creator + : createdName (noRest | classCreatorRest | arrayCreatorRest | mapCreatorRest | setCreatorRest) + ; + +createdName + : idCreatedNamePair (DOT idCreatedNamePair)* + ; + +idCreatedNamePair + : anyId (LT typeList GT)? + ; + +noRest + : LBRACE RBRACE + ; + +classCreatorRest + : arguments + ; + +arrayCreatorRest + : LBRACK expression RBRACK + | LBRACK RBRACK arrayInitializer? + ; + +mapCreatorRest + : LBRACE mapCreatorRestPair (COMMA mapCreatorRestPair )* RBRACE + ; + +mapCreatorRestPair + : expression MAPTO expression + ; + +setCreatorRest + : LBRACE expression (COMMA ( expression ))* RBRACE + ; + +arguments + : LPAREN expressionList? RPAREN + ; + +// SOQL + +soqlLiteral + : LBRACK query RBRACK + ; + +query + : SELECT selectList + FROM fromNameList + usingScope? + whereClause? + withClause? + groupByClause? + orderByClause? + limitClause? + offsetClause? + allRowsClause? + forClauses + (UPDATE updateList)? + ; + +subQuery + : SELECT subFieldList + FROM fromNameList + whereClause? + orderByClause? + limitClause? + forClauses + (UPDATE updateList)? + ; + +selectList + : selectEntry (COMMA selectEntry)*; + +selectEntry + : fieldName soqlId? + | soqlFunction soqlId? + | LPAREN subQuery RPAREN soqlId? + | typeOf + ; + +fieldName + : soqlId (DOT soqlId)*; + +fromNameList + : fieldName soqlId? (COMMA fieldName soqlId?)*; + +subFieldList + : subFieldEntry (COMMA subFieldEntry)*; + +subFieldEntry + : fieldName soqlId? + | soqlFunction soqlId? + | typeOf + ; + +soqlFieldsParameter + : ALL + | CUSTOM + | STANDARD; + +soqlFunction + : AVG LPAREN fieldName RPAREN + | COUNT LPAREN RPAREN + | COUNT LPAREN fieldName RPAREN + | COUNT_DISTINCT LPAREN fieldName RPAREN + | MIN LPAREN fieldName RPAREN + | MAX LPAREN fieldName RPAREN + | SUM LPAREN fieldName RPAREN + | TOLABEL LPAREN fieldName RPAREN + | FORMAT LPAREN fieldName RPAREN + | CALENDAR_MONTH LPAREN dateFieldName RPAREN + | CALENDAR_QUARTER LPAREN dateFieldName RPAREN + | CALENDAR_YEAR LPAREN dateFieldName RPAREN + | DAY_IN_MONTH LPAREN dateFieldName RPAREN + | DAY_IN_WEEK LPAREN dateFieldName RPAREN + | DAY_IN_YEAR LPAREN dateFieldName RPAREN + | DAY_ONLY LPAREN dateFieldName RPAREN + | FISCAL_MONTH LPAREN dateFieldName RPAREN + | FISCAL_QUARTER LPAREN dateFieldName RPAREN + | FISCAL_YEAR LPAREN dateFieldName RPAREN + | HOUR_IN_DAY LPAREN dateFieldName RPAREN + | WEEK_IN_MONTH LPAREN dateFieldName RPAREN + | WEEK_IN_YEAR LPAREN dateFieldName RPAREN + | FIELDS LPAREN soqlFieldsParameter RPAREN + | DISTANCE LPAREN locationValue COMMA locationValue COMMA StringLiteral RPAREN + ; + + dateFieldName + : CONVERT_TIMEZONE LPAREN fieldName RPAREN + | fieldName + ; + +locationValue + : fieldName + | boundExpression + | GEOLOCATION LPAREN coordinateValue COMMA coordinateValue RPAREN + ; + +coordinateValue + : signedNumber + | boundExpression + ; + +typeOf + : TYPEOF fieldName whenClause+ elseClause? END; + +whenClause + : WHEN fieldName THEN fieldNameList; + +elseClause + : ELSE fieldNameList; + +fieldNameList + : fieldName (COMMA fieldName)*; + +usingScope + : USING SCOPE soqlId; + +whereClause + : WHERE logicalExpression; + +logicalExpression + : conditionalExpression (SOQLAND conditionalExpression)* + | conditionalExpression (SOQLOR conditionalExpression)* + | NOT conditionalExpression; + +conditionalExpression + : LPAREN logicalExpression RPAREN + | fieldExpression; + +fieldExpression + : fieldName comparisonOperator value + | soqlFunction comparisonOperator value; + +comparisonOperator + : ASSIGN | NOTEQUAL | LT | GT | LT ASSIGN | GT ASSIGN | LESSANDGREATER | LIKE | IN | NOT IN | INCLUDES | EXCLUDES; + +value + : NULL + | BooleanLiteral + | signedNumber + | StringLiteral + | DateLiteral + | DateTimeLiteral + | dateFormula + | IntegralCurrencyLiteral (DOT IntegerLiteral?)? + | LPAREN subQuery RPAREN + | valueList + | boundExpression + ; + +valueList + : LPAREN value (COMMA value)* RPAREN; + +// TODO: NumberLiteral has trailing [dD]?, SOQL does not support this but a fix would need wider changes +signedNumber + : (ADD | SUB)? (IntegerLiteral | NumberLiteral); + +withClause + : WITH DATA CATEGORY filteringExpression + | WITH SECURITY_ENFORCED + | WITH SYSTEM_MODE + | WITH USER_MODE + | WITH logicalExpression; + +filteringExpression + : dataCategorySelection (AND dataCategorySelection)*; + +dataCategorySelection + : soqlId filteringSelector dataCategoryName; + +dataCategoryName + : soqlId + | LPAREN soqlId (COMMA soqlId)* LPAREN; + +filteringSelector + : AT | ABOVE | BELOW | ABOVE_OR_BELOW; + +groupByClause + : GROUP BY selectList (HAVING logicalExpression)? + | GROUP BY ROLLUP LPAREN fieldName (COMMA fieldName)* RPAREN + | GROUP BY CUBE LPAREN fieldName (COMMA fieldName)* RPAREN; + +orderByClause + : ORDER BY fieldOrderList; + +fieldOrderList + : fieldOrder (COMMA fieldOrder)*; + +fieldOrder + : fieldName (ASC | DESC)? (NULLS (FIRST|LAST))? + | soqlFunction (ASC | DESC)? (NULLS (FIRST|LAST))?; + +limitClause + : LIMIT IntegerLiteral + | LIMIT boundExpression; + +offsetClause + : OFFSET IntegerLiteral + | OFFSET boundExpression; + +allRowsClause + : ALL ROWS; + +forClauses + : (FOR (VIEW | UPDATE | REFERENCE))*; + +boundExpression + : COLON expression; + +dateFormula + : YESTERDAY + | TODAY + | TOMORROW + | LAST_WEEK + | THIS_WEEK + | NEXT_WEEK + | LAST_MONTH + | THIS_MONTH + | NEXT_MONTH + | LAST_90_DAYS + | NEXT_90_DAYS + | LAST_N_DAYS_N COLON signedInteger + | NEXT_N_DAYS_N COLON signedInteger + | N_DAYS_AGO_N COLON signedInteger + | NEXT_N_WEEKS_N COLON signedInteger + | LAST_N_WEEKS_N COLON signedInteger + | N_WEEKS_AGO_N COLON signedInteger + | NEXT_N_MONTHS_N COLON signedInteger + | LAST_N_MONTHS_N COLON signedInteger + | N_MONTHS_AGO_N COLON signedInteger + | THIS_QUARTER + | LAST_QUARTER + | NEXT_QUARTER + | NEXT_N_QUARTERS_N COLON signedInteger + | LAST_N_QUARTERS_N COLON signedInteger + | N_QUARTERS_AGO_N COLON signedInteger + | THIS_YEAR + | LAST_YEAR + | NEXT_YEAR + | NEXT_N_YEARS_N COLON signedInteger + | LAST_N_YEARS_N COLON signedInteger + | N_YEARS_AGO_N COLON signedInteger + | THIS_FISCAL_QUARTER + | LAST_FISCAL_QUARTER + | NEXT_FISCAL_QUARTER + | NEXT_N_FISCAL_QUARTERS_N COLON signedInteger + | LAST_N_FISCAL_QUARTERS_N COLON signedInteger + | N_FISCAL_QUARTERS_AGO_N COLON signedInteger + | THIS_FISCAL_YEAR + | LAST_FISCAL_YEAR + | NEXT_FISCAL_YEAR + | NEXT_N_FISCAL_YEARS_N COLON signedInteger + | LAST_N_FISCAL_YEARS_N COLON signedInteger + | N_FISCAL_YEARS_AGO_N COLON signedInteger + ; + +signedInteger + : (ADD | SUB)? IntegerLiteral; + +soqlId + : id; + +// SOSL +soslLiteral + : FindLiteral soslClauses RBRACK + | LBRACK FIND boundExpression soslClauses RBRACK + ; + +soslLiteralAlt + : FindLiteralAlt soslClauses RBRACK + ; + +soslClauses + : (IN searchGroup)? + (RETURNING fieldSpecList)? + (WITH DIVISION ASSIGN StringLiteral)? + (WITH DATA CATEGORY filteringExpression)? + (WITH SNIPPET (LPAREN TARGET_LENGTH ASSIGN IntegerLiteral RPAREN)? )? + (WITH NETWORK IN LPAREN networkList RPAREN)? + (WITH NETWORK ASSIGN StringLiteral)? + (WITH PRICEBOOKID ASSIGN StringLiteral)? + (WITH METADATA ASSIGN StringLiteral)? + limitClause? + (UPDATE updateList)? + ; + +searchGroup + : (ALL|EMAIL|NAME|PHONE|SIDEBAR) FIELDS + ; + +fieldSpecList + : fieldSpec (COMMA fieldSpecList)* + ; + +fieldSpec + : soslId (LPAREN fieldList + (WHERE logicalExpression)? + (USING LISTVIEW ASSIGN soslId)? + (ORDER BY fieldOrderList)? + limitClause? + offsetClause? + RPAREN)? + ; + +fieldList + : soslId (COMMA fieldList)* + ; + +updateList + : updateType (COMMA updateList)? + ; + +updateType + : TRACKING | VIEWSTAT; + +networkList + : StringLiteral (COMMA networkList)? + ; + +soslId + : id (DOT soslId)*; + +// Identifiers + +// Some keywords can be used as general identifiers, this is likely an over simplification of the actual +// rules but divining them from playing with Apex is very difficult. We could let any be used but that +// can significantly impact the parser performance by creating ambiguities. +id + : Identifier + | AFTER + | BEFORE + | GET + | INHERITED + | INSTANCEOF + | SET + | SHARING + | SWITCH + | TRANSIENT + | TRIGGER + | WHEN + | WITH + | WITHOUT + // DML Keywords + | USER + | SYSTEM + // SOQL Values + | IntegralCurrencyLiteral + // SOQL Specific Keywords + | SELECT + | COUNT + | FROM + | AS + | USING + | SCOPE + | WHERE + | ORDER + | BY + | LIMIT + | SOQLAND + | SOQLOR + | NOT + | AVG + | COUNT_DISTINCT + | MIN + | MAX + | SUM + | TYPEOF + | END + | THEN + | LIKE + | IN + | INCLUDES + | EXCLUDES + | ASC + | DESC + | NULLS + | FIRST + | LAST + | GROUP + | ALL + | ROWS + | VIEW + | HAVING + | ROLLUP + | TOLABEL + | OFFSET + | DATA + | CATEGORY + | AT + | ABOVE + | BELOW + | ABOVE_OR_BELOW + | SECURITY_ENFORCED + | USER_MODE + | SYSTEM_MODE + | REFERENCE + | CUBE + | FORMAT + | TRACKING + | VIEWSTAT + | STANDARD + | CUSTOM + | DISTANCE + | GEOLOCATION + // SOQL date functions + | CALENDAR_MONTH + | CALENDAR_QUARTER + | CALENDAR_YEAR + | DAY_IN_MONTH + | DAY_IN_WEEK + | DAY_IN_YEAR + | DAY_ONLY + | FISCAL_MONTH + | FISCAL_QUARTER + | FISCAL_YEAR + | HOUR_IN_DAY + | WEEK_IN_MONTH + | WEEK_IN_YEAR + | CONVERT_TIMEZONE + // SOQL date formulas + | YESTERDAY + | TODAY + | TOMORROW + | LAST_WEEK + | THIS_WEEK + | NEXT_WEEK + | LAST_MONTH + | THIS_MONTH + | NEXT_MONTH + | LAST_90_DAYS + | NEXT_90_DAYS + | LAST_N_DAYS_N + | NEXT_N_DAYS_N + | N_DAYS_AGO_N + | NEXT_N_WEEKS_N + | LAST_N_WEEKS_N + | N_WEEKS_AGO_N + | NEXT_N_MONTHS_N + | LAST_N_MONTHS_N + | N_MONTHS_AGO_N + | THIS_QUARTER + | LAST_QUARTER + | NEXT_QUARTER + | NEXT_N_QUARTERS_N + | LAST_N_QUARTERS_N + | N_QUARTERS_AGO_N + | THIS_YEAR + | LAST_YEAR + | NEXT_YEAR + | NEXT_N_YEARS_N + | LAST_N_YEARS_N + | N_YEARS_AGO_N + | THIS_FISCAL_QUARTER + | LAST_FISCAL_QUARTER + | NEXT_FISCAL_QUARTER + | NEXT_N_FISCAL_QUARTERS_N + | LAST_N_FISCAL_QUARTERS_N + | N_FISCAL_QUARTERS_AGO_N + | THIS_FISCAL_YEAR + | LAST_FISCAL_YEAR + | NEXT_FISCAL_YEAR + | NEXT_N_FISCAL_YEARS_N + | LAST_N_FISCAL_YEARS_N + | N_FISCAL_YEARS_AGO_N + // SOSL Keywords + | FIND + | EMAIL + | NAME + | PHONE + | SIDEBAR + | FIELDS + | METADATA + | PRICEBOOKID + | NETWORK + | SNIPPET + | TARGET_LENGTH + | DIVISION + | RETURNING + | LISTVIEW + ; + +// In dot expressions we, can use a wider set of of identifiers, apparently any of them althogh I have excluding VOID +// in the interests of reducing ambiguity +anyId + : Identifier + // Apex Keywords + | ABSTRACT + | AFTER + | BEFORE + | BREAK + | CATCH + | CLASS + | CONTINUE + | DELETE + | DO + | ELSE + | ENUM + | EXTENDS + | FINAL + | FINALLY + | FOR + | GET + | GLOBAL + | IF + | IMPLEMENTS + | INHERITED + | INSERT + | INSTANCEOF + | INTERFACE + | LIST + | MAP + | MERGE + | NEW + | NULL + | ON + | OVERRIDE + | PRIVATE + | PROTECTED + | PUBLIC + | RETURN + | SET + | SHARING + | STATIC + | SUPER + | SWITCH + | TESTMETHOD + | THIS + | THROW + | TRANSIENT + | TRIGGER + | TRY + | UNDELETE + | UPDATE + | UPSERT + | VIRTUAL + | WEBSERVICE + | WHEN + | WHILE + | WITH + | WITHOUT + // DML Keywords + | USER + | SYSTEM + // SOQL Values + | IntegralCurrencyLiteral + // SOQL Specific Keywords + | SELECT + | COUNT + | FROM + | AS + | USING + | SCOPE + | WHERE + | ORDER + | BY + | LIMIT + | SOQLAND + | SOQLOR + | NOT + | AVG + | COUNT_DISTINCT + | MIN + | MAX + | SUM + | TYPEOF + | END + | THEN + | LIKE + | IN + | INCLUDES + | EXCLUDES + | ASC + | DESC + | NULLS + | FIRST + | LAST + | GROUP + | ALL + | ROWS + | VIEW + | HAVING + | ROLLUP + | TOLABEL + | OFFSET + | DATA + | CATEGORY + | AT + | ABOVE + | BELOW + | ABOVE_OR_BELOW + | SECURITY_ENFORCED + | SYSTEM_MODE + | USER_MODE + | REFERENCE + | CUBE + | FORMAT + | TRACKING + | VIEWSTAT + | STANDARD + | CUSTOM + | DISTANCE + | GEOLOCATION + // SOQL date functions + | CALENDAR_MONTH + | CALENDAR_QUARTER + | CALENDAR_YEAR + | DAY_IN_MONTH + | DAY_IN_WEEK + | DAY_IN_YEAR + | DAY_ONLY + | FISCAL_MONTH + | FISCAL_QUARTER + | FISCAL_YEAR + | HOUR_IN_DAY + | WEEK_IN_MONTH + | WEEK_IN_YEAR + | CONVERT_TIMEZONE + // SOQL date formulas + | YESTERDAY + | TODAY + | TOMORROW + | LAST_WEEK + | THIS_WEEK + | NEXT_WEEK + | LAST_MONTH + | THIS_MONTH + | NEXT_MONTH + | LAST_90_DAYS + | NEXT_90_DAYS + | LAST_N_DAYS_N + | NEXT_N_DAYS_N + | N_DAYS_AGO_N + | NEXT_N_WEEKS_N + | LAST_N_WEEKS_N + | N_WEEKS_AGO_N + | NEXT_N_MONTHS_N + | LAST_N_MONTHS_N + | N_MONTHS_AGO_N + | THIS_QUARTER + | LAST_QUARTER + | NEXT_QUARTER + | NEXT_N_QUARTERS_N + | LAST_N_QUARTERS_N + | N_QUARTERS_AGO_N + | THIS_YEAR + | LAST_YEAR + | NEXT_YEAR + | NEXT_N_YEARS_N + | LAST_N_YEARS_N + | N_YEARS_AGO_N + | THIS_FISCAL_QUARTER + | LAST_FISCAL_QUARTER + | NEXT_FISCAL_QUARTER + | NEXT_N_FISCAL_QUARTERS_N + | LAST_N_FISCAL_QUARTERS_N + | N_FISCAL_QUARTERS_AGO_N + | THIS_FISCAL_YEAR + | LAST_FISCAL_YEAR + | NEXT_FISCAL_YEAR + | NEXT_N_FISCAL_YEARS_N + | LAST_N_FISCAL_YEARS_N + | N_FISCAL_YEARS_AGO_N + // SOSL Keywords + | FIND + | EMAIL + | NAME + | PHONE + | SIDEBAR + | FIELDS + | METADATA + | PRICEBOOKID + | NETWORK + | SNIPPET + | TARGET_LENGTH + | DIVISION + | RETURNING + | LISTVIEW + ; diff --git a/packages/apex/jest.config.js b/packages/apex/jest.config.js new file mode 100644 index 00000000..0e1a9e76 --- /dev/null +++ b/packages/apex/jest.config.js @@ -0,0 +1,12 @@ +module.exports = { + preset: 'ts-jest', + roots: [ 'src' ], + collectCoverage: true, + collectCoverageFrom: [ + 'src/**/*.{ts}', + '!**/node_modules/**' + ], + transform: { + '^.+\\.ts$': ['ts-jest', { isolatedModules: true, esModuleInterop: true }] + } +}; \ No newline at end of file diff --git a/packages/apex/package.json b/packages/apex/package.json new file mode 100644 index 00000000..d3ac0316 --- /dev/null +++ b/packages/apex/package.json @@ -0,0 +1,73 @@ +{ + "name": "@vlocode/apex", + "version": "0.21.7", + "description": "Salesforce APEX Parser and Grammar", + "keywords": [ + "Salesforce", + "APEX", + "ProgrammingLanguage", + "Parser", + "Grammar" + ], + "main": "lib/index.js", + "publishConfig": { + "main": "lib/index.js", + "typings": "lib/index.d.ts" + }, + "readme": "../SITE.md", + "directories": { + "lib": "./lib" + }, + "engines": { + "node": ">=16.0.0" + }, + "scripts": { + "build": "tsc", + "clean": "shx rm -rf ./lib ./coverage ./tsconfig.tsbuildinfo './*.tgz' './src/**/*.{d.ts,ts.map,js.map,js}'", + "watch": "tsc -w", + "pack": "pnpm run build && pnpm pack", + "prepublish": "pnpm run build", + "build-grammar": "antlr4ng -Dlanguage=TypeScript -o ./src/grammar -visitor -listener ./grammar/ApexLexer.g4 ./grammar/ApexParser.g4" + }, + "repository": { + "type": "git", + "url": "git+https://github.com/Codeneos/vlocode.git" + }, + "author": { + "name": "Peter van Gulik", + "email": "peter@curlybracket.nl" + }, + "files": [ + "lib/**/*.d.ts", + "lib/**/*.js", + "lib/**/*.json", + "patches/*.patch", + "../SITE.md" + ], + "license": "MIT", + "bugs": { + "url": "https://github.com/Codeneos/vlocode/issues" + }, + "homepage": "https://github.com/Codeneos/vlocode/tree/main/packages/apex#readme", + "devDependencies": { + "@types/csv-parse": "^1.2.2", + "@types/fs-extra": "^11", + "@types/jest": "^29.5.11", + "@types/jsforce": "^1.9.41", + "@types/luxon": "^3.3.0", + "@types/node": "^20.4.2", + "@types/tough-cookie": "^4.0.2", + "antlr4ng-cli": "^2.0.0", + "jest": "^29.7.0", + "nugget": "^2.2.0", + "shx": "^0.3.4", + "ts-jest": "^29.1.1", + "typescript": "5.1.6" + }, + "dependencies": { + "@vlocode/core": "workspace:*", + "@vlocode/util": "workspace:*", + "antlr4ng": "^3.0.4" + }, + "publisher": "curlybracket" +} diff --git a/packages/apex/src/__tests__/blockVistor.test.ts b/packages/apex/src/__tests__/blockVistor.test.ts new file mode 100644 index 00000000..2a9fc12e --- /dev/null +++ b/packages/apex/src/__tests__/blockVistor.test.ts @@ -0,0 +1,54 @@ +import { ApexSourceRange } from '../types'; +import { BlockVisitor } from '../visitors/blockVisitor'; + +describe('BlockVisitor', () => { + describe('resolveBlockHierarchy', () => { + it('should return the block hierarchy', () => { + const state = { + name: 'R', + sourceRange: ApexSourceRange.empty, + blocks: [ + { + name: 'A', + sourceRange: ApexSourceRange.empty, + blocks: [ + { name: 'A1', sourceRange: ApexSourceRange.empty } + ] + }, + { + name: 'B', + sourceRange: ApexSourceRange.empty, + blocks: [ + { name: 'B1', sourceRange: ApexSourceRange.empty }, + { name: 'B2', sourceRange: ApexSourceRange.empty }, + { + name: 'B3', sourceRange: ApexSourceRange.empty, + blocks: [ + { name: 'B3-1', sourceRange: ApexSourceRange.empty }, + { name: 'B3-2', sourceRange: ApexSourceRange.empty } + ] + } + ] + } + ] + }; + + const visitor = new BlockVisitor(state); + const result = Array.from(visitor.resolveBlockHierarchy()); + + // Assert + const blockNames = result.map(blocks => blocks.map(block => block['name'] as string)); + expect(blockNames).toEqual([ + ['R'], + ['R', 'A'], + ['R', 'A', 'A1'], + ['R', 'B'], + ['R', 'B', 'B1'], + ['R', 'B', 'B2'], + ['R', 'B', 'B3'], + ['R', 'B', 'B3', 'B3-1'], + ['R', 'B', 'B3', 'B3-2'] + ]); + }); + }); +}); \ No newline at end of file diff --git a/packages/apex/src/__tests__/parser.test.ts b/packages/apex/src/__tests__/parser.test.ts new file mode 100644 index 00000000..3b8515f7 --- /dev/null +++ b/packages/apex/src/__tests__/parser.test.ts @@ -0,0 +1,358 @@ +import 'jest'; +import { Parser } from '../parser'; + +describe('ApexParser', () => { + describe('#getCodeStructure', () => { + it('should parse local variable declarations', () => { + // Arrange + const code = ` + public class MyClass { + public void myMethod() { + String localVar1 = null; + String localVar2 = null; + if (localVar1 == localVar2) { + MyClass nested = new MyClass(); + } else { + OtherClass nested = new OtherClass(); + } + } + } + `; + + // Act + const actualCodeStructure = new Parser(code).getCodeStructure(); + + // Assert + const [ myMethod ] = actualCodeStructure.classes[0].methods; + const [ ifBlock, elseBlock ] = myMethod.blocks!; + expect(myMethod.localVariables.sort()).toMatchObject([ + { name: 'localVar1', type: { name: 'String', isSystemType: true } }, + { name: 'localVar2', type: { name: 'String', isSystemType: true } } + ]); + expect(ifBlock.localVariables).toMatchObject([ + { name: 'nested', type: { name: 'MyClass' } } + ]); + expect(elseBlock.localVariables).toMatchObject([ + { name: 'nested', type: { name: 'OtherClass' } } + ]); + expect([...new Set(myMethod.refs.map(r => r.name))].sort()).toEqual([ + 'MyClass', 'OtherClass', 'String' + ]); + }); + it('should parse class variable declarations', () => { + // Arrange + const code = ` + public class MyClass { + PRIVATE String classLocal1 = null; + protected String classLocal2 = null; + final MyClass nested = new MyClass(); + protected static String staticValue = null; + } + `; + + // Act + const actualCodeStructure = new Parser(code).getCodeStructure(); + + // Assert + const [ myClass ] = actualCodeStructure.classes; + expect(myClass.fields.sort()).toMatchObject([ + { name: 'classLocal1', access: 'private', type: { name: 'String' } }, + { name: 'classLocal2', access: 'protected',type: { name: 'String' } }, + { name: 'nested', isFinal: true, type: { name: 'MyClass' } }, + { name: 'staticValue', isStatic: true, access: 'protected', type: { name: 'String' } }, + ]); + expect(myClass.refs.map(r => r.name).sort()).toEqual(['MyClass', 'String' ]); + }); + it('should parse implemented interfaces', () => { + // Arrange + const code = ` + public class MyClass implements Interface1, Interface2 { + public void myMethod() { + } + } + `; + + // Act + const actualCodeStructure = new Parser(code).getCodeStructure(); + + // Assert + const [ myClass ] = actualCodeStructure.classes; + expect(myClass.implements.map(r => r.name).sort()).toEqual(['Interface1', 'Interface2']); + }); + it('should parse properties', () => { + // Arrange + const code = ` + public class MyClass { + + public String myProperty1 { get; set; } // Auto generated backing fields + + public String myProperty2 { + get { + return null; + } + } // Readonly property + } + `; + + // Act + const actualCodeStructure = new Parser(code).getCodeStructure(); + + // Assert + const [ myClass ] = actualCodeStructure.classes; + const [ myProperty1, myProperty2 ] = myClass.properties.sort(); + + expect(myProperty1).toMatchObject({ + name: 'myProperty1', + access: 'public', + type: { + name: 'String', + isSystemType: true + }, + sourceRange: { + start: { line: 4, column: 21 }, + stop: { line: 4, column: 60 } + } + }); + + expect(myProperty2).toMatchObject({ + name: 'myProperty2', + access: 'public', + type: { + name: 'String', + isSystemType: true + }, + sourceRange: { + start: { line: 6, column: 21 }, + stop: { line: 10, column: 22 } + } + }); + }); + it('should extract static member access as references', () => { + // Arrange + const code = ` + public class MyClass { + public void myMethod() { + String methodLocal = null; + ExternalClass1.externalMethod1(); + this.localMethod2(); + ExternalClass3.variable.method(); + } + } + `; + + // Act + const actualCodeStructure = new Parser(code).getCodeStructure(); + + // Assert + const [ myClass ] = actualCodeStructure.classes; + const [ myMethod ] = actualCodeStructure.classes[0].methods; + expect(myMethod.refs.sort()).toMatchObject([ + { name: 'String', isSystemType: true }, + { name: 'ExternalClass1', isSystemType: false }, + { name: 'ExternalClass3', isSystemType: false } + ]); + expect(myClass.refs.map(r => r.name).sort()).toEqual([ + 'ExternalClass1', 'ExternalClass3', 'String' + ]); + }); + it('should extract constructed types as references', () => { + // Arrange + const code = ` + public class MyClass { + public void myMethod() { + for(Object a : new ExternalClass1().getThings()) { + new ExternalClass2().externalMethod1(); + } + } + } + `; + + // Act + const actualCodeStructure = new Parser(code).getCodeStructure(); + + // Assert + const [ myMethod ] = actualCodeStructure.classes[0].methods; + expect(myMethod.refs.sort()).toMatchObject([ + { name: 'ExternalClass1', isSystemType: false }, + { name: 'ExternalClass2', isSystemType: false } + ]); + }); + it('should extract parameters types passed to constructed as references', () => { + // Arrange + const code = ` + public class MyClass { + public void myMethod() { + new ExternalClass1(new ExternalClass2(new ExternalClass3())); + } + } + `; + + // Act + const actualCodeStructure = new Parser(code).getCodeStructure(); + + // Assert + const [ myClass ] = actualCodeStructure.classes; + const [ myMethod ] = actualCodeStructure.classes[0].methods; + expect(myMethod.refs.sort()).toMatchObject([ + { name: 'ExternalClass1', isSystemType: false }, + { name: 'ExternalClass2', isSystemType: false }, + { name: 'ExternalClass3', isSystemType: false } + ]); + expect(myClass.refs.map(r => r.name).sort()).toEqual([ + 'ExternalClass1', 'ExternalClass2', 'ExternalClass3' + ]); + }); + it('should extract extended types as references', () => { + // Arrange + const code = ` + public class MyClass extends ExternalClass1 { + public void myMethod() { + } + } + `; + + // Act + const actualCodeStructure = new Parser(code).getCodeStructure(); + + // Assert + const [ myClass ] = actualCodeStructure.classes; + expect(myClass.refs.map(r => r.name).sort()).toEqual(['ExternalClass1']); + }); + it('should extract refs from property getter/setter', () => { + // Arrange + const code = ` + public class MyClass { + public String myProperty1 { + get { + return new ExternalClass1().externalMethod1(); + } + set { + value.externalMethod2(); + ExternalClass2.staticValue = value; + while(true) { + if (false) { + new ExternalClass3().test(value); + } + } + } + } + } + `; + + // Act + const actualCodeStructure = new Parser(code).getCodeStructure(); + + // Assert + const [ myClass ] = actualCodeStructure.classes; + const [ myProperty1 ] = actualCodeStructure.classes[0].properties; + expect(myProperty1.getter!.refs!.sort()).toMatchObject([ + { name: 'ExternalClass1' }, + ]); + expect(myProperty1.setter!.refs!.sort()).toMatchObject([ + { name: 'ExternalClass2' }, + { name: 'ExternalClass3' }, + ]); + expect(myClass.refs.map(r => r.name).sort()).toEqual([ + 'ExternalClass1', 'ExternalClass2', 'ExternalClass3', 'String' + ]); + }); + it('should parse ?? operator', () => { + // Arrange + const code = ` + public class MyClass { + public Object fn() { + return new BaseClass() ?? new OtherClass(); + } + } + `; + + // Act + const actualCodeStructure = new Parser(code).getCodeStructure(); + + // Assert + const [ myClass ] = actualCodeStructure.classes; + const [ fn ] = myClass.methods; + expect(fn.refs.map(r => r.name).sort()).toEqual([ + 'BaseClass', 'OtherClass' + ]); + }); + it('should not parse catch parameters as references', () => { + // Arrange + const code = ` + public class MyClass { + public void fn(String a) { + AuraHandledException ex = new AuraHandledException(new Class()); + try { + } catch(AuraHandledException e) { + ex = e; + } + ex.Asserter.isNotNull(ex); + Assert.isNotNull(ex); + } + } + `; + + // Act + const actualCodeStructure = new Parser(code).getCodeStructure(); + + // Assert + const [ myClass ] = actualCodeStructure.classes; + const [ fn ] = myClass.methods; + expect(fn.name).toEqual('fn'); + expect(fn.parameters.length).toEqual(1); + expect(fn.refs.map(r => r.name).sort()).toEqual([ + 'Assert', 'AuraHandledException', 'AuraHandledException', 'Class', 'String' + ]); + }); + it('should not parse local variables as references', () => { + // Arrange + const code = ` + public class MyClass { + Object local1 = null; + public void fn(String a) { + if (local1 != null) { + local2.someProperty.fn(); + } else { + local2 = this.local1; + local1 = new ExternalClass(); + } + } + Object local2 = null; + } + `; + + // Act + const actualCodeStructure = new Parser(code).getCodeStructure(); + + // Assert + const [ myClass ] = actualCodeStructure.classes; + const [ fn ] = myClass.methods; + expect(fn.name).toEqual('fn'); + expect(fn.parameters.length).toEqual(1); + expect(fn.refs.map(r => r.name).sort()).toEqual([ + 'ExternalClass', 'String' + ]); + }); + it('should include namespaces in parsed references', () => { + // Arrange + const code = ` + public class MyClass { + public void myMethod() { + System.Assert.isTrue(true, 'true'); + OtherClass.Value = 1; + } + } + `; + + // Act + const actualCodeStructure = new Parser(code).getCodeStructure(); + + // Assert + const [ myMethod ] = actualCodeStructure.classes[0].methods; + expect([...new Set(myMethod.refs.map(r => r.name))].sort()).toEqual([ + 'OtherClass', + 'System.Assert' + ]); + }); + }); +}); \ No newline at end of file diff --git a/packages/apex/src/__tests__/testIndentifier.test.ts b/packages/apex/src/__tests__/testIndentifier.test.ts new file mode 100644 index 00000000..5d915ade --- /dev/null +++ b/packages/apex/src/__tests__/testIndentifier.test.ts @@ -0,0 +1,49 @@ +import 'jest'; + +import { Logger, MemoryFileSystem } from '@vlocode/core'; +import { TestIdentifier } from '../testIndentifier'; + +describe('TestIdentifier', () => { + + const mockFs = new MemoryFileSystem({ + 'src/classes/MyClass.cls': 'class MyClass { MyClass2 dependency = new MyClass2(); }', + 'src/classes/MyClassTest.cls': '@isTest class MyClassTest { @isTest static void test() { new MyClass(); } }', + 'src/classes/MyClass2.cls': 'class MyClass2 { }', + 'src/classes/MyClassTest2.cls': '@isTest class MyClassTest2 { @isTest static void test() { new MyClass2(); } }', + }); + + describe('loadApexClasses', () => { + it('should load Apex classes and populate testClasses map', async () => { + // Arrange + const folders = ['src/classes']; + const testIdentifier = new TestIdentifier(mockFs, Logger.null); + + // Act + await testIdentifier.loadApexClasses(folders); + + // Assert + expect(testIdentifier['testClasses'].size).toBe(2); + expect(testIdentifier['apexClassesByName'].size).toBe(4); + expect(testIdentifier['fileToApexClass'].size).toBe(4); + + expect(testIdentifier['testClasses'].get('myclasstest')?.classCoverage).toEqual(['myclass']); + expect(testIdentifier['testClasses'].get('myclasstest2')?.classCoverage).toEqual(['myclass2']); + }); + }); + + describe('getTestClasses', () => { + it('should retrieve test classes that cover a given class', async () => { + // Arrange + const folders = ['src/classes']; + const testIdentifier = new TestIdentifier(mockFs, Logger.null); + + // Act + await testIdentifier.loadApexClasses(folders); + const result = testIdentifier.getTestClasses('MyClass'); + + // Assert + expect(result?.length).toBe(1); + expect(result).toEqual(['MyClassTest']); + }); + }); +}); \ No newline at end of file diff --git a/packages/apex/src/grammar/ApexLexer.ts b/packages/apex/src/grammar/ApexLexer.ts new file mode 100644 index 00000000..1043d1d9 --- /dev/null +++ b/packages/apex/src/grammar/ApexLexer.ts @@ -0,0 +1,1436 @@ +// Generated from ./grammar/ApexLexer.g4 by ANTLR 4.13.1 + +import * as antlr from "antlr4ng"; +import { Token } from "antlr4ng"; +import { CaseInsensitiveCharStream } from "../streams"; + + +export class ApexLexer extends antlr.Lexer { + public static readonly ABSTRACT = 1; + public static readonly AFTER = 2; + public static readonly BEFORE = 3; + public static readonly BREAK = 4; + public static readonly CATCH = 5; + public static readonly CLASS = 6; + public static readonly CONTINUE = 7; + public static readonly DELETE = 8; + public static readonly DO = 9; + public static readonly ELSE = 10; + public static readonly ENUM = 11; + public static readonly EXTENDS = 12; + public static readonly FINAL = 13; + public static readonly FINALLY = 14; + public static readonly FOR = 15; + public static readonly GET = 16; + public static readonly GLOBAL = 17; + public static readonly IF = 18; + public static readonly IMPLEMENTS = 19; + public static readonly INHERITED = 20; + public static readonly INSERT = 21; + public static readonly INSTANCEOF = 22; + public static readonly INTERFACE = 23; + public static readonly MERGE = 24; + public static readonly NEW = 25; + public static readonly NULL = 26; + public static readonly ON = 27; + public static readonly OVERRIDE = 28; + public static readonly PRIVATE = 29; + public static readonly PROTECTED = 30; + public static readonly PUBLIC = 31; + public static readonly RETURN = 32; + public static readonly SYSTEMRUNAS = 33; + public static readonly SET = 34; + public static readonly SHARING = 35; + public static readonly STATIC = 36; + public static readonly SUPER = 37; + public static readonly SWITCH = 38; + public static readonly TESTMETHOD = 39; + public static readonly THIS = 40; + public static readonly THROW = 41; + public static readonly TRANSIENT = 42; + public static readonly TRIGGER = 43; + public static readonly TRY = 44; + public static readonly UNDELETE = 45; + public static readonly UPDATE = 46; + public static readonly UPSERT = 47; + public static readonly VIRTUAL = 48; + public static readonly VOID = 49; + public static readonly WEBSERVICE = 50; + public static readonly WHEN = 51; + public static readonly WHILE = 52; + public static readonly WITH = 53; + public static readonly WITHOUT = 54; + public static readonly LIST = 55; + public static readonly MAP = 56; + public static readonly SYSTEM = 57; + public static readonly USER = 58; + public static readonly SELECT = 59; + public static readonly COUNT = 60; + public static readonly FROM = 61; + public static readonly AS = 62; + public static readonly USING = 63; + public static readonly SCOPE = 64; + public static readonly WHERE = 65; + public static readonly ORDER = 66; + public static readonly BY = 67; + public static readonly LIMIT = 68; + public static readonly SOQLAND = 69; + public static readonly SOQLOR = 70; + public static readonly NOT = 71; + public static readonly AVG = 72; + public static readonly COUNT_DISTINCT = 73; + public static readonly MIN = 74; + public static readonly MAX = 75; + public static readonly SUM = 76; + public static readonly TYPEOF = 77; + public static readonly END = 78; + public static readonly THEN = 79; + public static readonly LIKE = 80; + public static readonly IN = 81; + public static readonly INCLUDES = 82; + public static readonly EXCLUDES = 83; + public static readonly ASC = 84; + public static readonly DESC = 85; + public static readonly NULLS = 86; + public static readonly FIRST = 87; + public static readonly LAST = 88; + public static readonly GROUP = 89; + public static readonly ALL = 90; + public static readonly ROWS = 91; + public static readonly VIEW = 92; + public static readonly HAVING = 93; + public static readonly ROLLUP = 94; + public static readonly TOLABEL = 95; + public static readonly OFFSET = 96; + public static readonly DATA = 97; + public static readonly CATEGORY = 98; + public static readonly AT = 99; + public static readonly ABOVE = 100; + public static readonly BELOW = 101; + public static readonly ABOVE_OR_BELOW = 102; + public static readonly SECURITY_ENFORCED = 103; + public static readonly SYSTEM_MODE = 104; + public static readonly USER_MODE = 105; + public static readonly REFERENCE = 106; + public static readonly CUBE = 107; + public static readonly FORMAT = 108; + public static readonly TRACKING = 109; + public static readonly VIEWSTAT = 110; + public static readonly CUSTOM = 111; + public static readonly STANDARD = 112; + public static readonly DISTANCE = 113; + public static readonly GEOLOCATION = 114; + public static readonly CALENDAR_MONTH = 115; + public static readonly CALENDAR_QUARTER = 116; + public static readonly CALENDAR_YEAR = 117; + public static readonly DAY_IN_MONTH = 118; + public static readonly DAY_IN_WEEK = 119; + public static readonly DAY_IN_YEAR = 120; + public static readonly DAY_ONLY = 121; + public static readonly FISCAL_MONTH = 122; + public static readonly FISCAL_QUARTER = 123; + public static readonly FISCAL_YEAR = 124; + public static readonly HOUR_IN_DAY = 125; + public static readonly WEEK_IN_MONTH = 126; + public static readonly WEEK_IN_YEAR = 127; + public static readonly CONVERT_TIMEZONE = 128; + public static readonly YESTERDAY = 129; + public static readonly TODAY = 130; + public static readonly TOMORROW = 131; + public static readonly LAST_WEEK = 132; + public static readonly THIS_WEEK = 133; + public static readonly NEXT_WEEK = 134; + public static readonly LAST_MONTH = 135; + public static readonly THIS_MONTH = 136; + public static readonly NEXT_MONTH = 137; + public static readonly LAST_90_DAYS = 138; + public static readonly NEXT_90_DAYS = 139; + public static readonly LAST_N_DAYS_N = 140; + public static readonly NEXT_N_DAYS_N = 141; + public static readonly N_DAYS_AGO_N = 142; + public static readonly NEXT_N_WEEKS_N = 143; + public static readonly LAST_N_WEEKS_N = 144; + public static readonly N_WEEKS_AGO_N = 145; + public static readonly NEXT_N_MONTHS_N = 146; + public static readonly LAST_N_MONTHS_N = 147; + public static readonly N_MONTHS_AGO_N = 148; + public static readonly THIS_QUARTER = 149; + public static readonly LAST_QUARTER = 150; + public static readonly NEXT_QUARTER = 151; + public static readonly NEXT_N_QUARTERS_N = 152; + public static readonly LAST_N_QUARTERS_N = 153; + public static readonly N_QUARTERS_AGO_N = 154; + public static readonly THIS_YEAR = 155; + public static readonly LAST_YEAR = 156; + public static readonly NEXT_YEAR = 157; + public static readonly NEXT_N_YEARS_N = 158; + public static readonly LAST_N_YEARS_N = 159; + public static readonly N_YEARS_AGO_N = 160; + public static readonly THIS_FISCAL_QUARTER = 161; + public static readonly LAST_FISCAL_QUARTER = 162; + public static readonly NEXT_FISCAL_QUARTER = 163; + public static readonly NEXT_N_FISCAL_QUARTERS_N = 164; + public static readonly LAST_N_FISCAL_QUARTERS_N = 165; + public static readonly N_FISCAL_QUARTERS_AGO_N = 166; + public static readonly THIS_FISCAL_YEAR = 167; + public static readonly LAST_FISCAL_YEAR = 168; + public static readonly NEXT_FISCAL_YEAR = 169; + public static readonly NEXT_N_FISCAL_YEARS_N = 170; + public static readonly LAST_N_FISCAL_YEARS_N = 171; + public static readonly N_FISCAL_YEARS_AGO_N = 172; + public static readonly DateLiteral = 173; + public static readonly DateTimeLiteral = 174; + public static readonly IntegralCurrencyLiteral = 175; + public static readonly FIND = 176; + public static readonly EMAIL = 177; + public static readonly NAME = 178; + public static readonly PHONE = 179; + public static readonly SIDEBAR = 180; + public static readonly FIELDS = 181; + public static readonly METADATA = 182; + public static readonly PRICEBOOKID = 183; + public static readonly NETWORK = 184; + public static readonly SNIPPET = 185; + public static readonly TARGET_LENGTH = 186; + public static readonly DIVISION = 187; + public static readonly RETURNING = 188; + public static readonly LISTVIEW = 189; + public static readonly FindLiteral = 190; + public static readonly FindLiteralAlt = 191; + public static readonly IntegerLiteral = 192; + public static readonly LongLiteral = 193; + public static readonly NumberLiteral = 194; + public static readonly BooleanLiteral = 195; + public static readonly StringLiteral = 196; + public static readonly NullLiteral = 197; + public static readonly LPAREN = 198; + public static readonly RPAREN = 199; + public static readonly LBRACE = 200; + public static readonly RBRACE = 201; + public static readonly LBRACK = 202; + public static readonly RBRACK = 203; + public static readonly SEMI = 204; + public static readonly COMMA = 205; + public static readonly DOT = 206; + public static readonly ASSIGN = 207; + public static readonly GT = 208; + public static readonly LT = 209; + public static readonly BANG = 210; + public static readonly TILDE = 211; + public static readonly QUESTIONDOT = 212; + public static readonly QUESTION = 213; + public static readonly DOUBLEQUESTION = 214; + public static readonly COLON = 215; + public static readonly EQUAL = 216; + public static readonly TRIPLEEQUAL = 217; + public static readonly NOTEQUAL = 218; + public static readonly LESSANDGREATER = 219; + public static readonly TRIPLENOTEQUAL = 220; + public static readonly AND = 221; + public static readonly OR = 222; + public static readonly INC = 223; + public static readonly DEC = 224; + public static readonly ADD = 225; + public static readonly SUB = 226; + public static readonly MUL = 227; + public static readonly DIV = 228; + public static readonly BITAND = 229; + public static readonly BITOR = 230; + public static readonly CARET = 231; + public static readonly MAPTO = 232; + public static readonly ADD_ASSIGN = 233; + public static readonly SUB_ASSIGN = 234; + public static readonly MUL_ASSIGN = 235; + public static readonly DIV_ASSIGN = 236; + public static readonly AND_ASSIGN = 237; + public static readonly OR_ASSIGN = 238; + public static readonly XOR_ASSIGN = 239; + public static readonly LSHIFT_ASSIGN = 240; + public static readonly RSHIFT_ASSIGN = 241; + public static readonly URSHIFT_ASSIGN = 242; + public static readonly ATSIGN = 243; + public static readonly Identifier = 244; + public static readonly WS = 245; + public static readonly DOC_COMMENT = 246; + public static readonly COMMENT = 247; + public static readonly LINE_COMMENT = 248; + + public static readonly channelNames = [ + "DEFAULT_TOKEN_CHANNEL", "HIDDEN", "WHITESPACE_CHANNEL", "COMMENT_CHANNEL" + ]; + + public static readonly literalNames = [ + null, "'abstract'", "'after'", "'before'", "'break'", "'catch'", + "'class'", "'continue'", "'delete'", "'do'", "'else'", "'enum'", + "'extends'", "'final'", "'finally'", "'for'", "'get'", "'global'", + "'if'", "'implements'", "'inherited'", "'insert'", "'instanceof'", + "'interface'", "'merge'", "'new'", "'null'", "'on'", "'override'", + "'private'", "'protected'", "'public'", "'return'", "'system.runas'", + "'set'", "'sharing'", "'static'", "'super'", "'switch'", "'testmethod'", + "'this'", "'throw'", "'transient'", "'trigger'", "'try'", "'undelete'", + "'update'", "'upsert'", "'virtual'", "'void'", "'webservice'", "'when'", + "'while'", "'with'", "'without'", "'list'", "'map'", "'system'", + "'user'", "'select'", "'count'", "'from'", "'as'", "'using'", "'scope'", + "'where'", "'order'", "'by'", "'limit'", "'and'", "'or'", "'not'", + "'avg'", "'count_distinct'", "'min'", "'max'", "'sum'", "'typeof'", + "'end'", "'then'", "'like'", "'in'", "'includes'", "'excludes'", + "'asc'", "'desc'", "'nulls'", "'first'", "'last'", "'group'", "'all'", + "'rows'", "'view'", "'having'", "'rollup'", "'tolabel'", "'offset'", + "'data'", "'category'", "'at'", "'above'", "'below'", "'above_or_below'", + "'security_enforced'", "'system_mode'", "'user_mode'", "'reference'", + "'cube'", "'format'", "'tracking'", "'viewstat'", "'custom'", "'standard'", + "'distance'", "'geolocation'", "'calendar_month'", "'calendar_quarter'", + "'calendar_year'", "'day_in_month'", "'day_in_week'", "'day_in_year'", + "'day_only'", "'fiscal_month'", "'fiscal_quarter'", "'fiscal_year'", + "'hour_in_day'", "'week_in_month'", "'week_in_year'", "'converttimezone'", + "'yesterday'", "'today'", "'tomorrow'", "'last_week'", "'this_week'", + "'next_week'", "'last_month'", "'this_month'", "'next_month'", "'last_90_days'", + "'next_90_days'", "'last_n_days'", "'next_n_days'", "'n_days_ago'", + "'next_n_weeks'", "'last_n_weeks'", "'n_weeks_ago'", "'next_n_months'", + "'last_n_months'", "'n_months_ago'", "'this_quarter'", "'last_quarter'", + "'next_quarter'", "'next_n_quarters'", "'last_n_quarters'", "'n_quarters_ago'", + "'this_year'", "'last_year'", "'next_year'", "'next_n_years'", "'last_n_years'", + "'n_years_ago'", "'this_fiscal_quarter'", "'last_fiscal_quarter'", + "'next_fiscal_quarter'", "'next_n_fiscal_quarters'", "'last_n_fiscal_quarters'", + "'n_fiscal_quarters_ago'", "'this_fiscal_year'", "'last_fiscal_year'", + "'next_fiscal_year'", "'next_n_fiscal_years'", "'last_n_fiscal_years'", + "'n_fiscal_years_ago'", null, null, null, "'find'", "'email'", "'name'", + "'phone'", "'sidebar'", "'fields'", "'metadata'", "'pricebookid'", + "'network'", "'snippet'", "'target_length'", "'division'", "'returning'", + "'listview'", null, null, null, null, null, null, null, null, "'('", + "')'", "'{'", "'}'", "'['", "']'", "';'", "','", "'.'", "'='", "'>'", + "'<'", "'!'", "'~'", "'?.'", "'?'", "'??'", "':'", "'=='", "'==='", + "'!='", "'<>'", "'!=='", "'&&'", "'||'", "'++'", "'--'", "'+'", + "'-'", "'*'", "'/'", "'&'", "'|'", "'^'", "'=>'", "'+='", "'-='", + "'*='", "'/='", "'&='", "'|='", "'^='", "'<<='", "'>>='", "'>>>='", + "'@'" + ]; + + public static readonly symbolicNames = [ + null, "ABSTRACT", "AFTER", "BEFORE", "BREAK", "CATCH", "CLASS", + "CONTINUE", "DELETE", "DO", "ELSE", "ENUM", "EXTENDS", "FINAL", + "FINALLY", "FOR", "GET", "GLOBAL", "IF", "IMPLEMENTS", "INHERITED", + "INSERT", "INSTANCEOF", "INTERFACE", "MERGE", "NEW", "NULL", "ON", + "OVERRIDE", "PRIVATE", "PROTECTED", "PUBLIC", "RETURN", "SYSTEMRUNAS", + "SET", "SHARING", "STATIC", "SUPER", "SWITCH", "TESTMETHOD", "THIS", + "THROW", "TRANSIENT", "TRIGGER", "TRY", "UNDELETE", "UPDATE", "UPSERT", + "VIRTUAL", "VOID", "WEBSERVICE", "WHEN", "WHILE", "WITH", "WITHOUT", + "LIST", "MAP", "SYSTEM", "USER", "SELECT", "COUNT", "FROM", "AS", + "USING", "SCOPE", "WHERE", "ORDER", "BY", "LIMIT", "SOQLAND", "SOQLOR", + "NOT", "AVG", "COUNT_DISTINCT", "MIN", "MAX", "SUM", "TYPEOF", "END", + "THEN", "LIKE", "IN", "INCLUDES", "EXCLUDES", "ASC", "DESC", "NULLS", + "FIRST", "LAST", "GROUP", "ALL", "ROWS", "VIEW", "HAVING", "ROLLUP", + "TOLABEL", "OFFSET", "DATA", "CATEGORY", "AT", "ABOVE", "BELOW", + "ABOVE_OR_BELOW", "SECURITY_ENFORCED", "SYSTEM_MODE", "USER_MODE", + "REFERENCE", "CUBE", "FORMAT", "TRACKING", "VIEWSTAT", "CUSTOM", + "STANDARD", "DISTANCE", "GEOLOCATION", "CALENDAR_MONTH", "CALENDAR_QUARTER", + "CALENDAR_YEAR", "DAY_IN_MONTH", "DAY_IN_WEEK", "DAY_IN_YEAR", "DAY_ONLY", + "FISCAL_MONTH", "FISCAL_QUARTER", "FISCAL_YEAR", "HOUR_IN_DAY", + "WEEK_IN_MONTH", "WEEK_IN_YEAR", "CONVERT_TIMEZONE", "YESTERDAY", + "TODAY", "TOMORROW", "LAST_WEEK", "THIS_WEEK", "NEXT_WEEK", "LAST_MONTH", + "THIS_MONTH", "NEXT_MONTH", "LAST_90_DAYS", "NEXT_90_DAYS", "LAST_N_DAYS_N", + "NEXT_N_DAYS_N", "N_DAYS_AGO_N", "NEXT_N_WEEKS_N", "LAST_N_WEEKS_N", + "N_WEEKS_AGO_N", "NEXT_N_MONTHS_N", "LAST_N_MONTHS_N", "N_MONTHS_AGO_N", + "THIS_QUARTER", "LAST_QUARTER", "NEXT_QUARTER", "NEXT_N_QUARTERS_N", + "LAST_N_QUARTERS_N", "N_QUARTERS_AGO_N", "THIS_YEAR", "LAST_YEAR", + "NEXT_YEAR", "NEXT_N_YEARS_N", "LAST_N_YEARS_N", "N_YEARS_AGO_N", + "THIS_FISCAL_QUARTER", "LAST_FISCAL_QUARTER", "NEXT_FISCAL_QUARTER", + "NEXT_N_FISCAL_QUARTERS_N", "LAST_N_FISCAL_QUARTERS_N", "N_FISCAL_QUARTERS_AGO_N", + "THIS_FISCAL_YEAR", "LAST_FISCAL_YEAR", "NEXT_FISCAL_YEAR", "NEXT_N_FISCAL_YEARS_N", + "LAST_N_FISCAL_YEARS_N", "N_FISCAL_YEARS_AGO_N", "DateLiteral", + "DateTimeLiteral", "IntegralCurrencyLiteral", "FIND", "EMAIL", "NAME", + "PHONE", "SIDEBAR", "FIELDS", "METADATA", "PRICEBOOKID", "NETWORK", + "SNIPPET", "TARGET_LENGTH", "DIVISION", "RETURNING", "LISTVIEW", + "FindLiteral", "FindLiteralAlt", "IntegerLiteral", "LongLiteral", + "NumberLiteral", "BooleanLiteral", "StringLiteral", "NullLiteral", + "LPAREN", "RPAREN", "LBRACE", "RBRACE", "LBRACK", "RBRACK", "SEMI", + "COMMA", "DOT", "ASSIGN", "GT", "LT", "BANG", "TILDE", "QUESTIONDOT", + "QUESTION", "DOUBLEQUESTION", "COLON", "EQUAL", "TRIPLEEQUAL", "NOTEQUAL", + "LESSANDGREATER", "TRIPLENOTEQUAL", "AND", "OR", "INC", "DEC", "ADD", + "SUB", "MUL", "DIV", "BITAND", "BITOR", "CARET", "MAPTO", "ADD_ASSIGN", + "SUB_ASSIGN", "MUL_ASSIGN", "DIV_ASSIGN", "AND_ASSIGN", "OR_ASSIGN", + "XOR_ASSIGN", "LSHIFT_ASSIGN", "RSHIFT_ASSIGN", "URSHIFT_ASSIGN", + "ATSIGN", "Identifier", "WS", "DOC_COMMENT", "COMMENT", "LINE_COMMENT" + ]; + + public static readonly modeNames = [ + "DEFAULT_MODE", + ]; + + public static readonly ruleNames = [ + "ABSTRACT", "AFTER", "BEFORE", "BREAK", "CATCH", "CLASS", "CONTINUE", + "DELETE", "DO", "ELSE", "ENUM", "EXTENDS", "FINAL", "FINALLY", "FOR", + "GET", "GLOBAL", "IF", "IMPLEMENTS", "INHERITED", "INSERT", "INSTANCEOF", + "INTERFACE", "MERGE", "NEW", "NULL", "ON", "OVERRIDE", "PRIVATE", + "PROTECTED", "PUBLIC", "RETURN", "SYSTEMRUNAS", "SET", "SHARING", + "STATIC", "SUPER", "SWITCH", "TESTMETHOD", "THIS", "THROW", "TRANSIENT", + "TRIGGER", "TRY", "UNDELETE", "UPDATE", "UPSERT", "VIRTUAL", "VOID", + "WEBSERVICE", "WHEN", "WHILE", "WITH", "WITHOUT", "LIST", "MAP", + "SYSTEM", "USER", "SELECT", "COUNT", "FROM", "AS", "USING", "SCOPE", + "WHERE", "ORDER", "BY", "LIMIT", "SOQLAND", "SOQLOR", "NOT", "AVG", + "COUNT_DISTINCT", "MIN", "MAX", "SUM", "TYPEOF", "END", "THEN", + "LIKE", "IN", "INCLUDES", "EXCLUDES", "ASC", "DESC", "NULLS", "FIRST", + "LAST", "GROUP", "ALL", "ROWS", "VIEW", "HAVING", "ROLLUP", "TOLABEL", + "OFFSET", "DATA", "CATEGORY", "AT", "ABOVE", "BELOW", "ABOVE_OR_BELOW", + "SECURITY_ENFORCED", "SYSTEM_MODE", "USER_MODE", "REFERENCE", "CUBE", + "FORMAT", "TRACKING", "VIEWSTAT", "CUSTOM", "STANDARD", "DISTANCE", + "GEOLOCATION", "CALENDAR_MONTH", "CALENDAR_QUARTER", "CALENDAR_YEAR", + "DAY_IN_MONTH", "DAY_IN_WEEK", "DAY_IN_YEAR", "DAY_ONLY", "FISCAL_MONTH", + "FISCAL_QUARTER", "FISCAL_YEAR", "HOUR_IN_DAY", "WEEK_IN_MONTH", + "WEEK_IN_YEAR", "CONVERT_TIMEZONE", "YESTERDAY", "TODAY", "TOMORROW", + "LAST_WEEK", "THIS_WEEK", "NEXT_WEEK", "LAST_MONTH", "THIS_MONTH", + "NEXT_MONTH", "LAST_90_DAYS", "NEXT_90_DAYS", "LAST_N_DAYS_N", "NEXT_N_DAYS_N", + "N_DAYS_AGO_N", "NEXT_N_WEEKS_N", "LAST_N_WEEKS_N", "N_WEEKS_AGO_N", + "NEXT_N_MONTHS_N", "LAST_N_MONTHS_N", "N_MONTHS_AGO_N", "THIS_QUARTER", + "LAST_QUARTER", "NEXT_QUARTER", "NEXT_N_QUARTERS_N", "LAST_N_QUARTERS_N", + "N_QUARTERS_AGO_N", "THIS_YEAR", "LAST_YEAR", "NEXT_YEAR", "NEXT_N_YEARS_N", + "LAST_N_YEARS_N", "N_YEARS_AGO_N", "THIS_FISCAL_QUARTER", "LAST_FISCAL_QUARTER", + "NEXT_FISCAL_QUARTER", "NEXT_N_FISCAL_QUARTERS_N", "LAST_N_FISCAL_QUARTERS_N", + "N_FISCAL_QUARTERS_AGO_N", "THIS_FISCAL_YEAR", "LAST_FISCAL_YEAR", + "NEXT_FISCAL_YEAR", "NEXT_N_FISCAL_YEARS_N", "LAST_N_FISCAL_YEARS_N", + "N_FISCAL_YEARS_AGO_N", "DateLiteral", "DateTimeLiteral", "IntegralCurrencyLiteral", + "FIND", "EMAIL", "NAME", "PHONE", "SIDEBAR", "FIELDS", "METADATA", + "PRICEBOOKID", "NETWORK", "SNIPPET", "TARGET_LENGTH", "DIVISION", + "RETURNING", "LISTVIEW", "FindLiteral", "FindCharacters", "FindCharacter", + "FindLiteralAlt", "FindCharactersAlt", "FindCharacterAlt", "FindEscapeSequence", + "IntegerLiteral", "LongLiteral", "NumberLiteral", "HexCharacter", + "Digit", "BooleanLiteral", "StringLiteral", "StringCharacters", + "StringCharacter", "EscapeSequence", "NullLiteral", "LPAREN", "RPAREN", + "LBRACE", "RBRACE", "LBRACK", "RBRACK", "SEMI", "COMMA", "DOT", + "ASSIGN", "GT", "LT", "BANG", "TILDE", "QUESTIONDOT", "QUESTION", + "DOUBLEQUESTION", "COLON", "EQUAL", "TRIPLEEQUAL", "NOTEQUAL", "LESSANDGREATER", + "TRIPLENOTEQUAL", "AND", "OR", "INC", "DEC", "ADD", "SUB", "MUL", + "DIV", "BITAND", "BITOR", "CARET", "MAPTO", "ADD_ASSIGN", "SUB_ASSIGN", + "MUL_ASSIGN", "DIV_ASSIGN", "AND_ASSIGN", "OR_ASSIGN", "XOR_ASSIGN", + "LSHIFT_ASSIGN", "RSHIFT_ASSIGN", "URSHIFT_ASSIGN", "ATSIGN", "Identifier", + "JavaLetter", "JavaLetterOrDigit", "WS", "DOC_COMMENT", "COMMENT", + "LINE_COMMENT", + ]; + + + public constructor(input: antlr.CharStream) { + super(new CaseInsensitiveCharStream(input)); + this.interpreter = new antlr.LexerATNSimulator(this, ApexLexer._ATN, ApexLexer.decisionsToDFA, new antlr.PredictionContextCache()); + } + + public get grammarFileName(): string { return "ApexLexer.g4"; } + + public get literalNames(): (string | null)[] { return ApexLexer.literalNames; } + public get symbolicNames(): (string | null)[] { return ApexLexer.symbolicNames; } + public get ruleNames(): string[] { return ApexLexer.ruleNames; } + + public get serializedATN(): number[] { return ApexLexer._serializedATN; } + + public get channelNames(): string[] { return ApexLexer.channelNames; } + + public get modeNames(): string[] { return ApexLexer.modeNames; } + + public static readonly _serializedATN: number[] = [ + 4,0,248,2580,6,-1,2,0,7,0,2,1,7,1,2,2,7,2,2,3,7,3,2,4,7,4,2,5,7, + 5,2,6,7,6,2,7,7,7,2,8,7,8,2,9,7,9,2,10,7,10,2,11,7,11,2,12,7,12, + 2,13,7,13,2,14,7,14,2,15,7,15,2,16,7,16,2,17,7,17,2,18,7,18,2,19, + 7,19,2,20,7,20,2,21,7,21,2,22,7,22,2,23,7,23,2,24,7,24,2,25,7,25, + 2,26,7,26,2,27,7,27,2,28,7,28,2,29,7,29,2,30,7,30,2,31,7,31,2,32, + 7,32,2,33,7,33,2,34,7,34,2,35,7,35,2,36,7,36,2,37,7,37,2,38,7,38, + 2,39,7,39,2,40,7,40,2,41,7,41,2,42,7,42,2,43,7,43,2,44,7,44,2,45, + 7,45,2,46,7,46,2,47,7,47,2,48,7,48,2,49,7,49,2,50,7,50,2,51,7,51, + 2,52,7,52,2,53,7,53,2,54,7,54,2,55,7,55,2,56,7,56,2,57,7,57,2,58, + 7,58,2,59,7,59,2,60,7,60,2,61,7,61,2,62,7,62,2,63,7,63,2,64,7,64, + 2,65,7,65,2,66,7,66,2,67,7,67,2,68,7,68,2,69,7,69,2,70,7,70,2,71, + 7,71,2,72,7,72,2,73,7,73,2,74,7,74,2,75,7,75,2,76,7,76,2,77,7,77, + 2,78,7,78,2,79,7,79,2,80,7,80,2,81,7,81,2,82,7,82,2,83,7,83,2,84, + 7,84,2,85,7,85,2,86,7,86,2,87,7,87,2,88,7,88,2,89,7,89,2,90,7,90, + 2,91,7,91,2,92,7,92,2,93,7,93,2,94,7,94,2,95,7,95,2,96,7,96,2,97, + 7,97,2,98,7,98,2,99,7,99,2,100,7,100,2,101,7,101,2,102,7,102,2,103, + 7,103,2,104,7,104,2,105,7,105,2,106,7,106,2,107,7,107,2,108,7,108, + 2,109,7,109,2,110,7,110,2,111,7,111,2,112,7,112,2,113,7,113,2,114, + 7,114,2,115,7,115,2,116,7,116,2,117,7,117,2,118,7,118,2,119,7,119, + 2,120,7,120,2,121,7,121,2,122,7,122,2,123,7,123,2,124,7,124,2,125, + 7,125,2,126,7,126,2,127,7,127,2,128,7,128,2,129,7,129,2,130,7,130, + 2,131,7,131,2,132,7,132,2,133,7,133,2,134,7,134,2,135,7,135,2,136, + 7,136,2,137,7,137,2,138,7,138,2,139,7,139,2,140,7,140,2,141,7,141, + 2,142,7,142,2,143,7,143,2,144,7,144,2,145,7,145,2,146,7,146,2,147, + 7,147,2,148,7,148,2,149,7,149,2,150,7,150,2,151,7,151,2,152,7,152, + 2,153,7,153,2,154,7,154,2,155,7,155,2,156,7,156,2,157,7,157,2,158, + 7,158,2,159,7,159,2,160,7,160,2,161,7,161,2,162,7,162,2,163,7,163, + 2,164,7,164,2,165,7,165,2,166,7,166,2,167,7,167,2,168,7,168,2,169, + 7,169,2,170,7,170,2,171,7,171,2,172,7,172,2,173,7,173,2,174,7,174, + 2,175,7,175,2,176,7,176,2,177,7,177,2,178,7,178,2,179,7,179,2,180, + 7,180,2,181,7,181,2,182,7,182,2,183,7,183,2,184,7,184,2,185,7,185, + 2,186,7,186,2,187,7,187,2,188,7,188,2,189,7,189,2,190,7,190,2,191, + 7,191,2,192,7,192,2,193,7,193,2,194,7,194,2,195,7,195,2,196,7,196, + 2,197,7,197,2,198,7,198,2,199,7,199,2,200,7,200,2,201,7,201,2,202, + 7,202,2,203,7,203,2,204,7,204,2,205,7,205,2,206,7,206,2,207,7,207, + 2,208,7,208,2,209,7,209,2,210,7,210,2,211,7,211,2,212,7,212,2,213, + 7,213,2,214,7,214,2,215,7,215,2,216,7,216,2,217,7,217,2,218,7,218, + 2,219,7,219,2,220,7,220,2,221,7,221,2,222,7,222,2,223,7,223,2,224, + 7,224,2,225,7,225,2,226,7,226,2,227,7,227,2,228,7,228,2,229,7,229, + 2,230,7,230,2,231,7,231,2,232,7,232,2,233,7,233,2,234,7,234,2,235, + 7,235,2,236,7,236,2,237,7,237,2,238,7,238,2,239,7,239,2,240,7,240, + 2,241,7,241,2,242,7,242,2,243,7,243,2,244,7,244,2,245,7,245,2,246, + 7,246,2,247,7,247,2,248,7,248,2,249,7,249,2,250,7,250,2,251,7,251, + 2,252,7,252,2,253,7,253,2,254,7,254,2,255,7,255,2,256,7,256,2,257, + 7,257,2,258,7,258,2,259,7,259,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1, + 0,1,1,1,1,1,1,1,1,1,1,1,1,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,3,1,3,1, + 3,1,3,1,3,1,3,1,4,1,4,1,4,1,4,1,4,1,4,1,5,1,5,1,5,1,5,1,5,1,5,1, + 6,1,6,1,6,1,6,1,6,1,6,1,6,1,6,1,6,1,7,1,7,1,7,1,7,1,7,1,7,1,7,1, + 8,1,8,1,8,1,9,1,9,1,9,1,9,1,9,1,10,1,10,1,10,1,10,1,10,1,11,1,11, + 1,11,1,11,1,11,1,11,1,11,1,11,1,12,1,12,1,12,1,12,1,12,1,12,1,13, + 1,13,1,13,1,13,1,13,1,13,1,13,1,13,1,14,1,14,1,14,1,14,1,15,1,15, + 1,15,1,15,1,16,1,16,1,16,1,16,1,16,1,16,1,16,1,17,1,17,1,17,1,18, + 1,18,1,18,1,18,1,18,1,18,1,18,1,18,1,18,1,18,1,18,1,19,1,19,1,19, + 1,19,1,19,1,19,1,19,1,19,1,19,1,19,1,20,1,20,1,20,1,20,1,20,1,20, + 1,20,1,21,1,21,1,21,1,21,1,21,1,21,1,21,1,21,1,21,1,21,1,21,1,22, + 1,22,1,22,1,22,1,22,1,22,1,22,1,22,1,22,1,22,1,23,1,23,1,23,1,23, + 1,23,1,23,1,24,1,24,1,24,1,24,1,25,1,25,1,25,1,25,1,25,1,26,1,26, + 1,26,1,27,1,27,1,27,1,27,1,27,1,27,1,27,1,27,1,27,1,28,1,28,1,28, + 1,28,1,28,1,28,1,28,1,28,1,29,1,29,1,29,1,29,1,29,1,29,1,29,1,29, + 1,29,1,29,1,30,1,30,1,30,1,30,1,30,1,30,1,30,1,31,1,31,1,31,1,31, + 1,31,1,31,1,31,1,32,1,32,1,32,1,32,1,32,1,32,1,32,1,32,1,32,1,32, + 1,32,1,32,1,32,1,33,1,33,1,33,1,33,1,34,1,34,1,34,1,34,1,34,1,34, + 1,34,1,34,1,35,1,35,1,35,1,35,1,35,1,35,1,35,1,36,1,36,1,36,1,36, + 1,36,1,36,1,37,1,37,1,37,1,37,1,37,1,37,1,37,1,38,1,38,1,38,1,38, + 1,38,1,38,1,38,1,38,1,38,1,38,1,38,1,39,1,39,1,39,1,39,1,39,1,40, + 1,40,1,40,1,40,1,40,1,40,1,41,1,41,1,41,1,41,1,41,1,41,1,41,1,41, + 1,41,1,41,1,42,1,42,1,42,1,42,1,42,1,42,1,42,1,42,1,43,1,43,1,43, + 1,43,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,45,1,45,1,45, + 1,45,1,45,1,45,1,45,1,46,1,46,1,46,1,46,1,46,1,46,1,46,1,47,1,47, + 1,47,1,47,1,47,1,47,1,47,1,47,1,48,1,48,1,48,1,48,1,48,1,49,1,49, + 1,49,1,49,1,49,1,49,1,49,1,49,1,49,1,49,1,49,1,50,1,50,1,50,1,50, + 1,50,1,51,1,51,1,51,1,51,1,51,1,51,1,52,1,52,1,52,1,52,1,52,1,53, + 1,53,1,53,1,53,1,53,1,53,1,53,1,53,1,54,1,54,1,54,1,54,1,54,1,55, + 1,55,1,55,1,55,1,56,1,56,1,56,1,56,1,56,1,56,1,56,1,57,1,57,1,57, + 1,57,1,57,1,58,1,58,1,58,1,58,1,58,1,58,1,58,1,59,1,59,1,59,1,59, + 1,59,1,59,1,60,1,60,1,60,1,60,1,60,1,61,1,61,1,61,1,62,1,62,1,62, + 1,62,1,62,1,62,1,63,1,63,1,63,1,63,1,63,1,63,1,64,1,64,1,64,1,64, + 1,64,1,64,1,65,1,65,1,65,1,65,1,65,1,65,1,66,1,66,1,66,1,67,1,67, + 1,67,1,67,1,67,1,67,1,68,1,68,1,68,1,68,1,69,1,69,1,69,1,70,1,70, + 1,70,1,70,1,71,1,71,1,71,1,71,1,72,1,72,1,72,1,72,1,72,1,72,1,72, + 1,72,1,72,1,72,1,72,1,72,1,72,1,72,1,72,1,73,1,73,1,73,1,73,1,74, + 1,74,1,74,1,74,1,75,1,75,1,75,1,75,1,76,1,76,1,76,1,76,1,76,1,76, + 1,76,1,77,1,77,1,77,1,77,1,78,1,78,1,78,1,78,1,78,1,79,1,79,1,79, + 1,79,1,79,1,80,1,80,1,80,1,81,1,81,1,81,1,81,1,81,1,81,1,81,1,81, + 1,81,1,82,1,82,1,82,1,82,1,82,1,82,1,82,1,82,1,82,1,83,1,83,1,83, + 1,83,1,84,1,84,1,84,1,84,1,84,1,85,1,85,1,85,1,85,1,85,1,85,1,86, + 1,86,1,86,1,86,1,86,1,86,1,87,1,87,1,87,1,87,1,87,1,88,1,88,1,88, + 1,88,1,88,1,88,1,89,1,89,1,89,1,89,1,90,1,90,1,90,1,90,1,90,1,91, + 1,91,1,91,1,91,1,91,1,92,1,92,1,92,1,92,1,92,1,92,1,92,1,93,1,93, + 1,93,1,93,1,93,1,93,1,93,1,94,1,94,1,94,1,94,1,94,1,94,1,94,1,94, + 1,95,1,95,1,95,1,95,1,95,1,95,1,95,1,96,1,96,1,96,1,96,1,96,1,97, + 1,97,1,97,1,97,1,97,1,97,1,97,1,97,1,97,1,98,1,98,1,98,1,99,1,99, + 1,99,1,99,1,99,1,99,1,100,1,100,1,100,1,100,1,100,1,100,1,101,1, + 101,1,101,1,101,1,101,1,101,1,101,1,101,1,101,1,101,1,101,1,101, + 1,101,1,101,1,101,1,102,1,102,1,102,1,102,1,102,1,102,1,102,1,102, + 1,102,1,102,1,102,1,102,1,102,1,102,1,102,1,102,1,102,1,102,1,103, + 1,103,1,103,1,103,1,103,1,103,1,103,1,103,1,103,1,103,1,103,1,103, + 1,104,1,104,1,104,1,104,1,104,1,104,1,104,1,104,1,104,1,104,1,105, + 1,105,1,105,1,105,1,105,1,105,1,105,1,105,1,105,1,105,1,106,1,106, + 1,106,1,106,1,106,1,107,1,107,1,107,1,107,1,107,1,107,1,107,1,108, + 1,108,1,108,1,108,1,108,1,108,1,108,1,108,1,108,1,109,1,109,1,109, + 1,109,1,109,1,109,1,109,1,109,1,109,1,110,1,110,1,110,1,110,1,110, + 1,110,1,110,1,111,1,111,1,111,1,111,1,111,1,111,1,111,1,111,1,111, + 1,112,1,112,1,112,1,112,1,112,1,112,1,112,1,112,1,112,1,113,1,113, + 1,113,1,113,1,113,1,113,1,113,1,113,1,113,1,113,1,113,1,113,1,114, + 1,114,1,114,1,114,1,114,1,114,1,114,1,114,1,114,1,114,1,114,1,114, + 1,114,1,114,1,114,1,115,1,115,1,115,1,115,1,115,1,115,1,115,1,115, + 1,115,1,115,1,115,1,115,1,115,1,115,1,115,1,115,1,115,1,116,1,116, + 1,116,1,116,1,116,1,116,1,116,1,116,1,116,1,116,1,116,1,116,1,116, + 1,116,1,117,1,117,1,117,1,117,1,117,1,117,1,117,1,117,1,117,1,117, + 1,117,1,117,1,117,1,118,1,118,1,118,1,118,1,118,1,118,1,118,1,118, + 1,118,1,118,1,118,1,118,1,119,1,119,1,119,1,119,1,119,1,119,1,119, + 1,119,1,119,1,119,1,119,1,119,1,120,1,120,1,120,1,120,1,120,1,120, + 1,120,1,120,1,120,1,121,1,121,1,121,1,121,1,121,1,121,1,121,1,121, + 1,121,1,121,1,121,1,121,1,121,1,122,1,122,1,122,1,122,1,122,1,122, + 1,122,1,122,1,122,1,122,1,122,1,122,1,122,1,122,1,122,1,123,1,123, + 1,123,1,123,1,123,1,123,1,123,1,123,1,123,1,123,1,123,1,123,1,124, + 1,124,1,124,1,124,1,124,1,124,1,124,1,124,1,124,1,124,1,124,1,124, + 1,125,1,125,1,125,1,125,1,125,1,125,1,125,1,125,1,125,1,125,1,125, + 1,125,1,125,1,125,1,126,1,126,1,126,1,126,1,126,1,126,1,126,1,126, + 1,126,1,126,1,126,1,126,1,126,1,127,1,127,1,127,1,127,1,127,1,127, + 1,127,1,127,1,127,1,127,1,127,1,127,1,127,1,127,1,127,1,127,1,128, + 1,128,1,128,1,128,1,128,1,128,1,128,1,128,1,128,1,128,1,129,1,129, + 1,129,1,129,1,129,1,129,1,130,1,130,1,130,1,130,1,130,1,130,1,130, + 1,130,1,130,1,131,1,131,1,131,1,131,1,131,1,131,1,131,1,131,1,131, + 1,131,1,132,1,132,1,132,1,132,1,132,1,132,1,132,1,132,1,132,1,132, + 1,133,1,133,1,133,1,133,1,133,1,133,1,133,1,133,1,133,1,133,1,134, + 1,134,1,134,1,134,1,134,1,134,1,134,1,134,1,134,1,134,1,134,1,135, + 1,135,1,135,1,135,1,135,1,135,1,135,1,135,1,135,1,135,1,135,1,136, + 1,136,1,136,1,136,1,136,1,136,1,136,1,136,1,136,1,136,1,136,1,137, + 1,137,1,137,1,137,1,137,1,137,1,137,1,137,1,137,1,137,1,137,1,137, + 1,137,1,138,1,138,1,138,1,138,1,138,1,138,1,138,1,138,1,138,1,138, + 1,138,1,138,1,138,1,139,1,139,1,139,1,139,1,139,1,139,1,139,1,139, + 1,139,1,139,1,139,1,139,1,140,1,140,1,140,1,140,1,140,1,140,1,140, + 1,140,1,140,1,140,1,140,1,140,1,141,1,141,1,141,1,141,1,141,1,141, + 1,141,1,141,1,141,1,141,1,141,1,142,1,142,1,142,1,142,1,142,1,142, + 1,142,1,142,1,142,1,142,1,142,1,142,1,142,1,143,1,143,1,143,1,143, + 1,143,1,143,1,143,1,143,1,143,1,143,1,143,1,143,1,143,1,144,1,144, + 1,144,1,144,1,144,1,144,1,144,1,144,1,144,1,144,1,144,1,144,1,145, + 1,145,1,145,1,145,1,145,1,145,1,145,1,145,1,145,1,145,1,145,1,145, + 1,145,1,145,1,146,1,146,1,146,1,146,1,146,1,146,1,146,1,146,1,146, + 1,146,1,146,1,146,1,146,1,146,1,147,1,147,1,147,1,147,1,147,1,147, + 1,147,1,147,1,147,1,147,1,147,1,147,1,147,1,148,1,148,1,148,1,148, + 1,148,1,148,1,148,1,148,1,148,1,148,1,148,1,148,1,148,1,149,1,149, + 1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149, + 1,150,1,150,1,150,1,150,1,150,1,150,1,150,1,150,1,150,1,150,1,150, + 1,150,1,150,1,151,1,151,1,151,1,151,1,151,1,151,1,151,1,151,1,151, + 1,151,1,151,1,151,1,151,1,151,1,151,1,151,1,152,1,152,1,152,1,152, + 1,152,1,152,1,152,1,152,1,152,1,152,1,152,1,152,1,152,1,152,1,152, + 1,152,1,153,1,153,1,153,1,153,1,153,1,153,1,153,1,153,1,153,1,153, + 1,153,1,153,1,153,1,153,1,153,1,154,1,154,1,154,1,154,1,154,1,154, + 1,154,1,154,1,154,1,154,1,155,1,155,1,155,1,155,1,155,1,155,1,155, + 1,155,1,155,1,155,1,156,1,156,1,156,1,156,1,156,1,156,1,156,1,156, + 1,156,1,156,1,157,1,157,1,157,1,157,1,157,1,157,1,157,1,157,1,157, + 1,157,1,157,1,157,1,157,1,158,1,158,1,158,1,158,1,158,1,158,1,158, + 1,158,1,158,1,158,1,158,1,158,1,158,1,159,1,159,1,159,1,159,1,159, + 1,159,1,159,1,159,1,159,1,159,1,159,1,159,1,160,1,160,1,160,1,160, + 1,160,1,160,1,160,1,160,1,160,1,160,1,160,1,160,1,160,1,160,1,160, + 1,160,1,160,1,160,1,160,1,160,1,161,1,161,1,161,1,161,1,161,1,161, + 1,161,1,161,1,161,1,161,1,161,1,161,1,161,1,161,1,161,1,161,1,161, + 1,161,1,161,1,161,1,162,1,162,1,162,1,162,1,162,1,162,1,162,1,162, + 1,162,1,162,1,162,1,162,1,162,1,162,1,162,1,162,1,162,1,162,1,162, + 1,162,1,163,1,163,1,163,1,163,1,163,1,163,1,163,1,163,1,163,1,163, + 1,163,1,163,1,163,1,163,1,163,1,163,1,163,1,163,1,163,1,163,1,163, + 1,163,1,163,1,164,1,164,1,164,1,164,1,164,1,164,1,164,1,164,1,164, + 1,164,1,164,1,164,1,164,1,164,1,164,1,164,1,164,1,164,1,164,1,164, + 1,164,1,164,1,164,1,165,1,165,1,165,1,165,1,165,1,165,1,165,1,165, + 1,165,1,165,1,165,1,165,1,165,1,165,1,165,1,165,1,165,1,165,1,165, + 1,165,1,165,1,165,1,166,1,166,1,166,1,166,1,166,1,166,1,166,1,166, + 1,166,1,166,1,166,1,166,1,166,1,166,1,166,1,166,1,166,1,167,1,167, + 1,167,1,167,1,167,1,167,1,167,1,167,1,167,1,167,1,167,1,167,1,167, + 1,167,1,167,1,167,1,167,1,168,1,168,1,168,1,168,1,168,1,168,1,168, + 1,168,1,168,1,168,1,168,1,168,1,168,1,168,1,168,1,168,1,168,1,169, + 1,169,1,169,1,169,1,169,1,169,1,169,1,169,1,169,1,169,1,169,1,169, + 1,169,1,169,1,169,1,169,1,169,1,169,1,169,1,169,1,170,1,170,1,170, + 1,170,1,170,1,170,1,170,1,170,1,170,1,170,1,170,1,170,1,170,1,170, + 1,170,1,170,1,170,1,170,1,170,1,170,1,171,1,171,1,171,1,171,1,171, + 1,171,1,171,1,171,1,171,1,171,1,171,1,171,1,171,1,171,1,171,1,171, + 1,171,1,171,1,171,1,172,1,172,1,172,1,172,1,172,1,172,1,172,1,172, + 1,172,1,172,1,172,1,173,1,173,1,173,1,173,1,173,1,173,1,173,1,173, + 1,173,1,173,1,173,1,173,1,173,4,173,2125,8,173,11,173,12,173,2126, + 1,173,1,173,4,173,2131,8,173,11,173,12,173,2132,3,173,2135,8,173, + 3,173,2137,8,173,1,174,1,174,1,174,1,174,4,174,2143,8,174,11,174, + 12,174,2144,1,175,1,175,1,175,1,175,1,175,1,176,1,176,1,176,1,176, + 1,176,1,176,1,177,1,177,1,177,1,177,1,177,1,178,1,178,1,178,1,178, + 1,178,1,178,1,179,1,179,1,179,1,179,1,179,1,179,1,179,1,179,1,180, + 1,180,1,180,1,180,1,180,1,180,1,180,1,181,1,181,1,181,1,181,1,181, + 1,181,1,181,1,181,1,181,1,182,1,182,1,182,1,182,1,182,1,182,1,182, + 1,182,1,182,1,182,1,182,1,182,1,183,1,183,1,183,1,183,1,183,1,183, + 1,183,1,183,1,184,1,184,1,184,1,184,1,184,1,184,1,184,1,184,1,185, + 1,185,1,185,1,185,1,185,1,185,1,185,1,185,1,185,1,185,1,185,1,185, + 1,185,1,185,1,186,1,186,1,186,1,186,1,186,1,186,1,186,1,186,1,186, + 1,187,1,187,1,187,1,187,1,187,1,187,1,187,1,187,1,187,1,187,1,188, + 1,188,1,188,1,188,1,188,1,188,1,188,1,188,1,188,1,189,1,189,3,189, + 2265,8,189,1,189,1,189,1,189,1,189,1,189,1,189,1,189,1,189,3,189, + 2275,8,189,1,189,1,189,1,190,4,190,2280,8,190,11,190,12,190,2281, + 1,191,1,191,3,191,2286,8,191,1,192,1,192,3,192,2290,8,192,1,192, + 1,192,1,192,1,192,1,192,1,192,1,192,1,192,3,192,2300,8,192,1,192, + 1,192,1,193,4,193,2305,8,193,11,193,12,193,2306,1,194,1,194,3,194, + 2311,8,194,1,195,1,195,1,195,1,196,1,196,5,196,2318,8,196,10,196, + 12,196,2321,9,196,1,197,1,197,5,197,2325,8,197,10,197,12,197,2328, + 9,197,1,197,1,197,1,198,5,198,2333,8,198,10,198,12,198,2336,9,198, + 1,198,1,198,1,198,5,198,2341,8,198,10,198,12,198,2344,9,198,1,198, + 3,198,2347,8,198,1,199,1,199,3,199,2351,8,199,1,200,1,200,1,201, + 1,201,1,201,1,201,1,201,1,201,1,201,1,201,1,201,3,201,2364,8,201, + 1,202,1,202,3,202,2368,8,202,1,202,1,202,1,203,4,203,2373,8,203, + 11,203,12,203,2374,1,204,1,204,3,204,2379,8,204,1,205,1,205,1,205, + 1,205,1,205,1,205,1,205,1,205,1,205,1,205,3,205,2391,8,205,1,206, + 1,206,1,207,1,207,1,208,1,208,1,209,1,209,1,210,1,210,1,211,1,211, + 1,212,1,212,1,213,1,213,1,214,1,214,1,215,1,215,1,216,1,216,1,217, + 1,217,1,218,1,218,1,219,1,219,1,220,1,220,1,221,1,221,1,221,1,222, + 1,222,1,223,1,223,1,223,1,224,1,224,1,225,1,225,1,225,1,226,1,226, + 1,226,1,226,1,227,1,227,1,227,1,228,1,228,1,228,1,229,1,229,1,229, + 1,229,1,230,1,230,1,230,1,231,1,231,1,231,1,232,1,232,1,232,1,233, + 1,233,1,233,1,234,1,234,1,235,1,235,1,236,1,236,1,237,1,237,1,238, + 1,238,1,239,1,239,1,240,1,240,1,241,1,241,1,241,1,242,1,242,1,242, + 1,243,1,243,1,243,1,244,1,244,1,244,1,245,1,245,1,245,1,246,1,246, + 1,246,1,247,1,247,1,247,1,248,1,248,1,248,1,249,1,249,1,249,1,249, + 1,250,1,250,1,250,1,250,1,251,1,251,1,251,1,251,1,251,1,252,1,252, + 1,253,1,253,5,253,2517,8,253,10,253,12,253,2520,9,253,1,254,1,254, + 1,254,1,254,3,254,2526,8,254,1,255,1,255,1,255,1,255,3,255,2532, + 8,255,1,256,4,256,2535,8,256,11,256,12,256,2536,1,256,1,256,1,257, + 1,257,1,257,1,257,1,257,5,257,2546,8,257,10,257,12,257,2549,9,257, + 1,257,1,257,1,257,1,257,1,257,1,258,1,258,1,258,1,258,5,258,2560, + 8,258,10,258,12,258,2563,9,258,1,258,1,258,1,258,1,258,1,258,1,259, + 1,259,1,259,1,259,5,259,2574,8,259,10,259,12,259,2577,9,259,1,259, + 1,259,2,2547,2561,0,260,1,1,3,2,5,3,7,4,9,5,11,6,13,7,15,8,17,9, + 19,10,21,11,23,12,25,13,27,14,29,15,31,16,33,17,35,18,37,19,39,20, + 41,21,43,22,45,23,47,24,49,25,51,26,53,27,55,28,57,29,59,30,61,31, + 63,32,65,33,67,34,69,35,71,36,73,37,75,38,77,39,79,40,81,41,83,42, + 85,43,87,44,89,45,91,46,93,47,95,48,97,49,99,50,101,51,103,52,105, + 53,107,54,109,55,111,56,113,57,115,58,117,59,119,60,121,61,123,62, + 125,63,127,64,129,65,131,66,133,67,135,68,137,69,139,70,141,71,143, + 72,145,73,147,74,149,75,151,76,153,77,155,78,157,79,159,80,161,81, + 163,82,165,83,167,84,169,85,171,86,173,87,175,88,177,89,179,90,181, + 91,183,92,185,93,187,94,189,95,191,96,193,97,195,98,197,99,199,100, + 201,101,203,102,205,103,207,104,209,105,211,106,213,107,215,108, + 217,109,219,110,221,111,223,112,225,113,227,114,229,115,231,116, + 233,117,235,118,237,119,239,120,241,121,243,122,245,123,247,124, + 249,125,251,126,253,127,255,128,257,129,259,130,261,131,263,132, + 265,133,267,134,269,135,271,136,273,137,275,138,277,139,279,140, + 281,141,283,142,285,143,287,144,289,145,291,146,293,147,295,148, + 297,149,299,150,301,151,303,152,305,153,307,154,309,155,311,156, + 313,157,315,158,317,159,319,160,321,161,323,162,325,163,327,164, + 329,165,331,166,333,167,335,168,337,169,339,170,341,171,343,172, + 345,173,347,174,349,175,351,176,353,177,355,178,357,179,359,180, + 361,181,363,182,365,183,367,184,369,185,371,186,373,187,375,188, + 377,189,379,190,381,0,383,0,385,191,387,0,389,0,391,0,393,192,395, + 193,397,194,399,0,401,0,403,195,405,196,407,0,409,0,411,0,413,197, + 415,198,417,199,419,200,421,201,423,202,425,203,427,204,429,205, + 431,206,433,207,435,208,437,209,439,210,441,211,443,212,445,213, + 447,214,449,215,451,216,453,217,455,218,457,219,459,220,461,221, + 463,222,465,223,467,224,469,225,471,226,473,227,475,228,477,229, + 479,230,481,231,483,232,485,233,487,234,489,235,491,236,493,237, + 495,238,497,239,499,240,501,241,503,242,505,243,507,244,509,0,511, + 0,513,245,515,246,517,247,519,248,1,0,16,2,0,43,43,45,45,1,0,97, + 122,2,0,39,39,92,92,2,0,92,92,125,125,8,0,33,34,38,43,45,45,58,58, + 63,63,92,92,94,94,123,126,2,0,76,76,108,108,2,0,68,68,100,100,1, + 0,48,57,8,0,34,34,39,39,92,92,98,98,102,102,110,110,114,114,116, + 116,4,0,36,36,65,90,95,95,97,122,2,0,0,255,55296,56319,1,0,55296, + 56319,1,0,56320,57343,5,0,36,36,48,57,65,90,95,95,97,122,3,0,9,10, + 12,13,32,32,2,0,10,10,13,13,2600,0,1,1,0,0,0,0,3,1,0,0,0,0,5,1,0, + 0,0,0,7,1,0,0,0,0,9,1,0,0,0,0,11,1,0,0,0,0,13,1,0,0,0,0,15,1,0,0, + 0,0,17,1,0,0,0,0,19,1,0,0,0,0,21,1,0,0,0,0,23,1,0,0,0,0,25,1,0,0, + 0,0,27,1,0,0,0,0,29,1,0,0,0,0,31,1,0,0,0,0,33,1,0,0,0,0,35,1,0,0, + 0,0,37,1,0,0,0,0,39,1,0,0,0,0,41,1,0,0,0,0,43,1,0,0,0,0,45,1,0,0, + 0,0,47,1,0,0,0,0,49,1,0,0,0,0,51,1,0,0,0,0,53,1,0,0,0,0,55,1,0,0, + 0,0,57,1,0,0,0,0,59,1,0,0,0,0,61,1,0,0,0,0,63,1,0,0,0,0,65,1,0,0, + 0,0,67,1,0,0,0,0,69,1,0,0,0,0,71,1,0,0,0,0,73,1,0,0,0,0,75,1,0,0, + 0,0,77,1,0,0,0,0,79,1,0,0,0,0,81,1,0,0,0,0,83,1,0,0,0,0,85,1,0,0, + 0,0,87,1,0,0,0,0,89,1,0,0,0,0,91,1,0,0,0,0,93,1,0,0,0,0,95,1,0,0, + 0,0,97,1,0,0,0,0,99,1,0,0,0,0,101,1,0,0,0,0,103,1,0,0,0,0,105,1, + 0,0,0,0,107,1,0,0,0,0,109,1,0,0,0,0,111,1,0,0,0,0,113,1,0,0,0,0, + 115,1,0,0,0,0,117,1,0,0,0,0,119,1,0,0,0,0,121,1,0,0,0,0,123,1,0, + 0,0,0,125,1,0,0,0,0,127,1,0,0,0,0,129,1,0,0,0,0,131,1,0,0,0,0,133, + 1,0,0,0,0,135,1,0,0,0,0,137,1,0,0,0,0,139,1,0,0,0,0,141,1,0,0,0, + 0,143,1,0,0,0,0,145,1,0,0,0,0,147,1,0,0,0,0,149,1,0,0,0,0,151,1, + 0,0,0,0,153,1,0,0,0,0,155,1,0,0,0,0,157,1,0,0,0,0,159,1,0,0,0,0, + 161,1,0,0,0,0,163,1,0,0,0,0,165,1,0,0,0,0,167,1,0,0,0,0,169,1,0, + 0,0,0,171,1,0,0,0,0,173,1,0,0,0,0,175,1,0,0,0,0,177,1,0,0,0,0,179, + 1,0,0,0,0,181,1,0,0,0,0,183,1,0,0,0,0,185,1,0,0,0,0,187,1,0,0,0, + 0,189,1,0,0,0,0,191,1,0,0,0,0,193,1,0,0,0,0,195,1,0,0,0,0,197,1, + 0,0,0,0,199,1,0,0,0,0,201,1,0,0,0,0,203,1,0,0,0,0,205,1,0,0,0,0, + 207,1,0,0,0,0,209,1,0,0,0,0,211,1,0,0,0,0,213,1,0,0,0,0,215,1,0, + 0,0,0,217,1,0,0,0,0,219,1,0,0,0,0,221,1,0,0,0,0,223,1,0,0,0,0,225, + 1,0,0,0,0,227,1,0,0,0,0,229,1,0,0,0,0,231,1,0,0,0,0,233,1,0,0,0, + 0,235,1,0,0,0,0,237,1,0,0,0,0,239,1,0,0,0,0,241,1,0,0,0,0,243,1, + 0,0,0,0,245,1,0,0,0,0,247,1,0,0,0,0,249,1,0,0,0,0,251,1,0,0,0,0, + 253,1,0,0,0,0,255,1,0,0,0,0,257,1,0,0,0,0,259,1,0,0,0,0,261,1,0, + 0,0,0,263,1,0,0,0,0,265,1,0,0,0,0,267,1,0,0,0,0,269,1,0,0,0,0,271, + 1,0,0,0,0,273,1,0,0,0,0,275,1,0,0,0,0,277,1,0,0,0,0,279,1,0,0,0, + 0,281,1,0,0,0,0,283,1,0,0,0,0,285,1,0,0,0,0,287,1,0,0,0,0,289,1, + 0,0,0,0,291,1,0,0,0,0,293,1,0,0,0,0,295,1,0,0,0,0,297,1,0,0,0,0, + 299,1,0,0,0,0,301,1,0,0,0,0,303,1,0,0,0,0,305,1,0,0,0,0,307,1,0, + 0,0,0,309,1,0,0,0,0,311,1,0,0,0,0,313,1,0,0,0,0,315,1,0,0,0,0,317, + 1,0,0,0,0,319,1,0,0,0,0,321,1,0,0,0,0,323,1,0,0,0,0,325,1,0,0,0, + 0,327,1,0,0,0,0,329,1,0,0,0,0,331,1,0,0,0,0,333,1,0,0,0,0,335,1, + 0,0,0,0,337,1,0,0,0,0,339,1,0,0,0,0,341,1,0,0,0,0,343,1,0,0,0,0, + 345,1,0,0,0,0,347,1,0,0,0,0,349,1,0,0,0,0,351,1,0,0,0,0,353,1,0, + 0,0,0,355,1,0,0,0,0,357,1,0,0,0,0,359,1,0,0,0,0,361,1,0,0,0,0,363, + 1,0,0,0,0,365,1,0,0,0,0,367,1,0,0,0,0,369,1,0,0,0,0,371,1,0,0,0, + 0,373,1,0,0,0,0,375,1,0,0,0,0,377,1,0,0,0,0,379,1,0,0,0,0,385,1, + 0,0,0,0,393,1,0,0,0,0,395,1,0,0,0,0,397,1,0,0,0,0,403,1,0,0,0,0, + 405,1,0,0,0,0,413,1,0,0,0,0,415,1,0,0,0,0,417,1,0,0,0,0,419,1,0, + 0,0,0,421,1,0,0,0,0,423,1,0,0,0,0,425,1,0,0,0,0,427,1,0,0,0,0,429, + 1,0,0,0,0,431,1,0,0,0,0,433,1,0,0,0,0,435,1,0,0,0,0,437,1,0,0,0, + 0,439,1,0,0,0,0,441,1,0,0,0,0,443,1,0,0,0,0,445,1,0,0,0,0,447,1, + 0,0,0,0,449,1,0,0,0,0,451,1,0,0,0,0,453,1,0,0,0,0,455,1,0,0,0,0, + 457,1,0,0,0,0,459,1,0,0,0,0,461,1,0,0,0,0,463,1,0,0,0,0,465,1,0, + 0,0,0,467,1,0,0,0,0,469,1,0,0,0,0,471,1,0,0,0,0,473,1,0,0,0,0,475, + 1,0,0,0,0,477,1,0,0,0,0,479,1,0,0,0,0,481,1,0,0,0,0,483,1,0,0,0, + 0,485,1,0,0,0,0,487,1,0,0,0,0,489,1,0,0,0,0,491,1,0,0,0,0,493,1, + 0,0,0,0,495,1,0,0,0,0,497,1,0,0,0,0,499,1,0,0,0,0,501,1,0,0,0,0, + 503,1,0,0,0,0,505,1,0,0,0,0,507,1,0,0,0,0,513,1,0,0,0,0,515,1,0, + 0,0,0,517,1,0,0,0,0,519,1,0,0,0,1,521,1,0,0,0,3,530,1,0,0,0,5,536, + 1,0,0,0,7,543,1,0,0,0,9,549,1,0,0,0,11,555,1,0,0,0,13,561,1,0,0, + 0,15,570,1,0,0,0,17,577,1,0,0,0,19,580,1,0,0,0,21,585,1,0,0,0,23, + 590,1,0,0,0,25,598,1,0,0,0,27,604,1,0,0,0,29,612,1,0,0,0,31,616, + 1,0,0,0,33,620,1,0,0,0,35,627,1,0,0,0,37,630,1,0,0,0,39,641,1,0, + 0,0,41,651,1,0,0,0,43,658,1,0,0,0,45,669,1,0,0,0,47,679,1,0,0,0, + 49,685,1,0,0,0,51,689,1,0,0,0,53,694,1,0,0,0,55,697,1,0,0,0,57,706, + 1,0,0,0,59,714,1,0,0,0,61,724,1,0,0,0,63,731,1,0,0,0,65,738,1,0, + 0,0,67,751,1,0,0,0,69,755,1,0,0,0,71,763,1,0,0,0,73,770,1,0,0,0, + 75,776,1,0,0,0,77,783,1,0,0,0,79,794,1,0,0,0,81,799,1,0,0,0,83,805, + 1,0,0,0,85,815,1,0,0,0,87,823,1,0,0,0,89,827,1,0,0,0,91,836,1,0, + 0,0,93,843,1,0,0,0,95,850,1,0,0,0,97,858,1,0,0,0,99,863,1,0,0,0, + 101,874,1,0,0,0,103,879,1,0,0,0,105,885,1,0,0,0,107,890,1,0,0,0, + 109,898,1,0,0,0,111,903,1,0,0,0,113,907,1,0,0,0,115,914,1,0,0,0, + 117,919,1,0,0,0,119,926,1,0,0,0,121,932,1,0,0,0,123,937,1,0,0,0, + 125,940,1,0,0,0,127,946,1,0,0,0,129,952,1,0,0,0,131,958,1,0,0,0, + 133,964,1,0,0,0,135,967,1,0,0,0,137,973,1,0,0,0,139,977,1,0,0,0, + 141,980,1,0,0,0,143,984,1,0,0,0,145,988,1,0,0,0,147,1003,1,0,0,0, + 149,1007,1,0,0,0,151,1011,1,0,0,0,153,1015,1,0,0,0,155,1022,1,0, + 0,0,157,1026,1,0,0,0,159,1031,1,0,0,0,161,1036,1,0,0,0,163,1039, + 1,0,0,0,165,1048,1,0,0,0,167,1057,1,0,0,0,169,1061,1,0,0,0,171,1066, + 1,0,0,0,173,1072,1,0,0,0,175,1078,1,0,0,0,177,1083,1,0,0,0,179,1089, + 1,0,0,0,181,1093,1,0,0,0,183,1098,1,0,0,0,185,1103,1,0,0,0,187,1110, + 1,0,0,0,189,1117,1,0,0,0,191,1125,1,0,0,0,193,1132,1,0,0,0,195,1137, + 1,0,0,0,197,1146,1,0,0,0,199,1149,1,0,0,0,201,1155,1,0,0,0,203,1161, + 1,0,0,0,205,1176,1,0,0,0,207,1194,1,0,0,0,209,1206,1,0,0,0,211,1216, + 1,0,0,0,213,1226,1,0,0,0,215,1231,1,0,0,0,217,1238,1,0,0,0,219,1247, + 1,0,0,0,221,1256,1,0,0,0,223,1263,1,0,0,0,225,1272,1,0,0,0,227,1281, + 1,0,0,0,229,1293,1,0,0,0,231,1308,1,0,0,0,233,1325,1,0,0,0,235,1339, + 1,0,0,0,237,1352,1,0,0,0,239,1364,1,0,0,0,241,1376,1,0,0,0,243,1385, + 1,0,0,0,245,1398,1,0,0,0,247,1413,1,0,0,0,249,1425,1,0,0,0,251,1437, + 1,0,0,0,253,1451,1,0,0,0,255,1464,1,0,0,0,257,1480,1,0,0,0,259,1490, + 1,0,0,0,261,1496,1,0,0,0,263,1505,1,0,0,0,265,1515,1,0,0,0,267,1525, + 1,0,0,0,269,1535,1,0,0,0,271,1546,1,0,0,0,273,1557,1,0,0,0,275,1568, + 1,0,0,0,277,1581,1,0,0,0,279,1594,1,0,0,0,281,1606,1,0,0,0,283,1618, + 1,0,0,0,285,1629,1,0,0,0,287,1642,1,0,0,0,289,1655,1,0,0,0,291,1667, + 1,0,0,0,293,1681,1,0,0,0,295,1695,1,0,0,0,297,1708,1,0,0,0,299,1721, + 1,0,0,0,301,1734,1,0,0,0,303,1747,1,0,0,0,305,1763,1,0,0,0,307,1779, + 1,0,0,0,309,1794,1,0,0,0,311,1804,1,0,0,0,313,1814,1,0,0,0,315,1824, + 1,0,0,0,317,1837,1,0,0,0,319,1850,1,0,0,0,321,1862,1,0,0,0,323,1882, + 1,0,0,0,325,1902,1,0,0,0,327,1922,1,0,0,0,329,1945,1,0,0,0,331,1968, + 1,0,0,0,333,1990,1,0,0,0,335,2007,1,0,0,0,337,2024,1,0,0,0,339,2041, + 1,0,0,0,341,2061,1,0,0,0,343,2081,1,0,0,0,345,2100,1,0,0,0,347,2111, + 1,0,0,0,349,2138,1,0,0,0,351,2146,1,0,0,0,353,2151,1,0,0,0,355,2157, + 1,0,0,0,357,2162,1,0,0,0,359,2168,1,0,0,0,361,2176,1,0,0,0,363,2183, + 1,0,0,0,365,2192,1,0,0,0,367,2204,1,0,0,0,369,2212,1,0,0,0,371,2220, + 1,0,0,0,373,2234,1,0,0,0,375,2243,1,0,0,0,377,2253,1,0,0,0,379,2262, + 1,0,0,0,381,2279,1,0,0,0,383,2285,1,0,0,0,385,2287,1,0,0,0,387,2304, + 1,0,0,0,389,2310,1,0,0,0,391,2312,1,0,0,0,393,2315,1,0,0,0,395,2322, + 1,0,0,0,397,2334,1,0,0,0,399,2350,1,0,0,0,401,2352,1,0,0,0,403,2363, + 1,0,0,0,405,2365,1,0,0,0,407,2372,1,0,0,0,409,2378,1,0,0,0,411,2390, + 1,0,0,0,413,2392,1,0,0,0,415,2394,1,0,0,0,417,2396,1,0,0,0,419,2398, + 1,0,0,0,421,2400,1,0,0,0,423,2402,1,0,0,0,425,2404,1,0,0,0,427,2406, + 1,0,0,0,429,2408,1,0,0,0,431,2410,1,0,0,0,433,2412,1,0,0,0,435,2414, + 1,0,0,0,437,2416,1,0,0,0,439,2418,1,0,0,0,441,2420,1,0,0,0,443,2422, + 1,0,0,0,445,2425,1,0,0,0,447,2427,1,0,0,0,449,2430,1,0,0,0,451,2432, + 1,0,0,0,453,2435,1,0,0,0,455,2439,1,0,0,0,457,2442,1,0,0,0,459,2445, + 1,0,0,0,461,2449,1,0,0,0,463,2452,1,0,0,0,465,2455,1,0,0,0,467,2458, + 1,0,0,0,469,2461,1,0,0,0,471,2463,1,0,0,0,473,2465,1,0,0,0,475,2467, + 1,0,0,0,477,2469,1,0,0,0,479,2471,1,0,0,0,481,2473,1,0,0,0,483,2475, + 1,0,0,0,485,2478,1,0,0,0,487,2481,1,0,0,0,489,2484,1,0,0,0,491,2487, + 1,0,0,0,493,2490,1,0,0,0,495,2493,1,0,0,0,497,2496,1,0,0,0,499,2499, + 1,0,0,0,501,2503,1,0,0,0,503,2507,1,0,0,0,505,2512,1,0,0,0,507,2514, + 1,0,0,0,509,2525,1,0,0,0,511,2531,1,0,0,0,513,2534,1,0,0,0,515,2540, + 1,0,0,0,517,2555,1,0,0,0,519,2569,1,0,0,0,521,522,5,97,0,0,522,523, + 5,98,0,0,523,524,5,115,0,0,524,525,5,116,0,0,525,526,5,114,0,0,526, + 527,5,97,0,0,527,528,5,99,0,0,528,529,5,116,0,0,529,2,1,0,0,0,530, + 531,5,97,0,0,531,532,5,102,0,0,532,533,5,116,0,0,533,534,5,101,0, + 0,534,535,5,114,0,0,535,4,1,0,0,0,536,537,5,98,0,0,537,538,5,101, + 0,0,538,539,5,102,0,0,539,540,5,111,0,0,540,541,5,114,0,0,541,542, + 5,101,0,0,542,6,1,0,0,0,543,544,5,98,0,0,544,545,5,114,0,0,545,546, + 5,101,0,0,546,547,5,97,0,0,547,548,5,107,0,0,548,8,1,0,0,0,549,550, + 5,99,0,0,550,551,5,97,0,0,551,552,5,116,0,0,552,553,5,99,0,0,553, + 554,5,104,0,0,554,10,1,0,0,0,555,556,5,99,0,0,556,557,5,108,0,0, + 557,558,5,97,0,0,558,559,5,115,0,0,559,560,5,115,0,0,560,12,1,0, + 0,0,561,562,5,99,0,0,562,563,5,111,0,0,563,564,5,110,0,0,564,565, + 5,116,0,0,565,566,5,105,0,0,566,567,5,110,0,0,567,568,5,117,0,0, + 568,569,5,101,0,0,569,14,1,0,0,0,570,571,5,100,0,0,571,572,5,101, + 0,0,572,573,5,108,0,0,573,574,5,101,0,0,574,575,5,116,0,0,575,576, + 5,101,0,0,576,16,1,0,0,0,577,578,5,100,0,0,578,579,5,111,0,0,579, + 18,1,0,0,0,580,581,5,101,0,0,581,582,5,108,0,0,582,583,5,115,0,0, + 583,584,5,101,0,0,584,20,1,0,0,0,585,586,5,101,0,0,586,587,5,110, + 0,0,587,588,5,117,0,0,588,589,5,109,0,0,589,22,1,0,0,0,590,591,5, + 101,0,0,591,592,5,120,0,0,592,593,5,116,0,0,593,594,5,101,0,0,594, + 595,5,110,0,0,595,596,5,100,0,0,596,597,5,115,0,0,597,24,1,0,0,0, + 598,599,5,102,0,0,599,600,5,105,0,0,600,601,5,110,0,0,601,602,5, + 97,0,0,602,603,5,108,0,0,603,26,1,0,0,0,604,605,5,102,0,0,605,606, + 5,105,0,0,606,607,5,110,0,0,607,608,5,97,0,0,608,609,5,108,0,0,609, + 610,5,108,0,0,610,611,5,121,0,0,611,28,1,0,0,0,612,613,5,102,0,0, + 613,614,5,111,0,0,614,615,5,114,0,0,615,30,1,0,0,0,616,617,5,103, + 0,0,617,618,5,101,0,0,618,619,5,116,0,0,619,32,1,0,0,0,620,621,5, + 103,0,0,621,622,5,108,0,0,622,623,5,111,0,0,623,624,5,98,0,0,624, + 625,5,97,0,0,625,626,5,108,0,0,626,34,1,0,0,0,627,628,5,105,0,0, + 628,629,5,102,0,0,629,36,1,0,0,0,630,631,5,105,0,0,631,632,5,109, + 0,0,632,633,5,112,0,0,633,634,5,108,0,0,634,635,5,101,0,0,635,636, + 5,109,0,0,636,637,5,101,0,0,637,638,5,110,0,0,638,639,5,116,0,0, + 639,640,5,115,0,0,640,38,1,0,0,0,641,642,5,105,0,0,642,643,5,110, + 0,0,643,644,5,104,0,0,644,645,5,101,0,0,645,646,5,114,0,0,646,647, + 5,105,0,0,647,648,5,116,0,0,648,649,5,101,0,0,649,650,5,100,0,0, + 650,40,1,0,0,0,651,652,5,105,0,0,652,653,5,110,0,0,653,654,5,115, + 0,0,654,655,5,101,0,0,655,656,5,114,0,0,656,657,5,116,0,0,657,42, + 1,0,0,0,658,659,5,105,0,0,659,660,5,110,0,0,660,661,5,115,0,0,661, + 662,5,116,0,0,662,663,5,97,0,0,663,664,5,110,0,0,664,665,5,99,0, + 0,665,666,5,101,0,0,666,667,5,111,0,0,667,668,5,102,0,0,668,44,1, + 0,0,0,669,670,5,105,0,0,670,671,5,110,0,0,671,672,5,116,0,0,672, + 673,5,101,0,0,673,674,5,114,0,0,674,675,5,102,0,0,675,676,5,97,0, + 0,676,677,5,99,0,0,677,678,5,101,0,0,678,46,1,0,0,0,679,680,5,109, + 0,0,680,681,5,101,0,0,681,682,5,114,0,0,682,683,5,103,0,0,683,684, + 5,101,0,0,684,48,1,0,0,0,685,686,5,110,0,0,686,687,5,101,0,0,687, + 688,5,119,0,0,688,50,1,0,0,0,689,690,5,110,0,0,690,691,5,117,0,0, + 691,692,5,108,0,0,692,693,5,108,0,0,693,52,1,0,0,0,694,695,5,111, + 0,0,695,696,5,110,0,0,696,54,1,0,0,0,697,698,5,111,0,0,698,699,5, + 118,0,0,699,700,5,101,0,0,700,701,5,114,0,0,701,702,5,114,0,0,702, + 703,5,105,0,0,703,704,5,100,0,0,704,705,5,101,0,0,705,56,1,0,0,0, + 706,707,5,112,0,0,707,708,5,114,0,0,708,709,5,105,0,0,709,710,5, + 118,0,0,710,711,5,97,0,0,711,712,5,116,0,0,712,713,5,101,0,0,713, + 58,1,0,0,0,714,715,5,112,0,0,715,716,5,114,0,0,716,717,5,111,0,0, + 717,718,5,116,0,0,718,719,5,101,0,0,719,720,5,99,0,0,720,721,5,116, + 0,0,721,722,5,101,0,0,722,723,5,100,0,0,723,60,1,0,0,0,724,725,5, + 112,0,0,725,726,5,117,0,0,726,727,5,98,0,0,727,728,5,108,0,0,728, + 729,5,105,0,0,729,730,5,99,0,0,730,62,1,0,0,0,731,732,5,114,0,0, + 732,733,5,101,0,0,733,734,5,116,0,0,734,735,5,117,0,0,735,736,5, + 114,0,0,736,737,5,110,0,0,737,64,1,0,0,0,738,739,5,115,0,0,739,740, + 5,121,0,0,740,741,5,115,0,0,741,742,5,116,0,0,742,743,5,101,0,0, + 743,744,5,109,0,0,744,745,5,46,0,0,745,746,5,114,0,0,746,747,5,117, + 0,0,747,748,5,110,0,0,748,749,5,97,0,0,749,750,5,115,0,0,750,66, + 1,0,0,0,751,752,5,115,0,0,752,753,5,101,0,0,753,754,5,116,0,0,754, + 68,1,0,0,0,755,756,5,115,0,0,756,757,5,104,0,0,757,758,5,97,0,0, + 758,759,5,114,0,0,759,760,5,105,0,0,760,761,5,110,0,0,761,762,5, + 103,0,0,762,70,1,0,0,0,763,764,5,115,0,0,764,765,5,116,0,0,765,766, + 5,97,0,0,766,767,5,116,0,0,767,768,5,105,0,0,768,769,5,99,0,0,769, + 72,1,0,0,0,770,771,5,115,0,0,771,772,5,117,0,0,772,773,5,112,0,0, + 773,774,5,101,0,0,774,775,5,114,0,0,775,74,1,0,0,0,776,777,5,115, + 0,0,777,778,5,119,0,0,778,779,5,105,0,0,779,780,5,116,0,0,780,781, + 5,99,0,0,781,782,5,104,0,0,782,76,1,0,0,0,783,784,5,116,0,0,784, + 785,5,101,0,0,785,786,5,115,0,0,786,787,5,116,0,0,787,788,5,109, + 0,0,788,789,5,101,0,0,789,790,5,116,0,0,790,791,5,104,0,0,791,792, + 5,111,0,0,792,793,5,100,0,0,793,78,1,0,0,0,794,795,5,116,0,0,795, + 796,5,104,0,0,796,797,5,105,0,0,797,798,5,115,0,0,798,80,1,0,0,0, + 799,800,5,116,0,0,800,801,5,104,0,0,801,802,5,114,0,0,802,803,5, + 111,0,0,803,804,5,119,0,0,804,82,1,0,0,0,805,806,5,116,0,0,806,807, + 5,114,0,0,807,808,5,97,0,0,808,809,5,110,0,0,809,810,5,115,0,0,810, + 811,5,105,0,0,811,812,5,101,0,0,812,813,5,110,0,0,813,814,5,116, + 0,0,814,84,1,0,0,0,815,816,5,116,0,0,816,817,5,114,0,0,817,818,5, + 105,0,0,818,819,5,103,0,0,819,820,5,103,0,0,820,821,5,101,0,0,821, + 822,5,114,0,0,822,86,1,0,0,0,823,824,5,116,0,0,824,825,5,114,0,0, + 825,826,5,121,0,0,826,88,1,0,0,0,827,828,5,117,0,0,828,829,5,110, + 0,0,829,830,5,100,0,0,830,831,5,101,0,0,831,832,5,108,0,0,832,833, + 5,101,0,0,833,834,5,116,0,0,834,835,5,101,0,0,835,90,1,0,0,0,836, + 837,5,117,0,0,837,838,5,112,0,0,838,839,5,100,0,0,839,840,5,97,0, + 0,840,841,5,116,0,0,841,842,5,101,0,0,842,92,1,0,0,0,843,844,5,117, + 0,0,844,845,5,112,0,0,845,846,5,115,0,0,846,847,5,101,0,0,847,848, + 5,114,0,0,848,849,5,116,0,0,849,94,1,0,0,0,850,851,5,118,0,0,851, + 852,5,105,0,0,852,853,5,114,0,0,853,854,5,116,0,0,854,855,5,117, + 0,0,855,856,5,97,0,0,856,857,5,108,0,0,857,96,1,0,0,0,858,859,5, + 118,0,0,859,860,5,111,0,0,860,861,5,105,0,0,861,862,5,100,0,0,862, + 98,1,0,0,0,863,864,5,119,0,0,864,865,5,101,0,0,865,866,5,98,0,0, + 866,867,5,115,0,0,867,868,5,101,0,0,868,869,5,114,0,0,869,870,5, + 118,0,0,870,871,5,105,0,0,871,872,5,99,0,0,872,873,5,101,0,0,873, + 100,1,0,0,0,874,875,5,119,0,0,875,876,5,104,0,0,876,877,5,101,0, + 0,877,878,5,110,0,0,878,102,1,0,0,0,879,880,5,119,0,0,880,881,5, + 104,0,0,881,882,5,105,0,0,882,883,5,108,0,0,883,884,5,101,0,0,884, + 104,1,0,0,0,885,886,5,119,0,0,886,887,5,105,0,0,887,888,5,116,0, + 0,888,889,5,104,0,0,889,106,1,0,0,0,890,891,5,119,0,0,891,892,5, + 105,0,0,892,893,5,116,0,0,893,894,5,104,0,0,894,895,5,111,0,0,895, + 896,5,117,0,0,896,897,5,116,0,0,897,108,1,0,0,0,898,899,5,108,0, + 0,899,900,5,105,0,0,900,901,5,115,0,0,901,902,5,116,0,0,902,110, + 1,0,0,0,903,904,5,109,0,0,904,905,5,97,0,0,905,906,5,112,0,0,906, + 112,1,0,0,0,907,908,5,115,0,0,908,909,5,121,0,0,909,910,5,115,0, + 0,910,911,5,116,0,0,911,912,5,101,0,0,912,913,5,109,0,0,913,114, + 1,0,0,0,914,915,5,117,0,0,915,916,5,115,0,0,916,917,5,101,0,0,917, + 918,5,114,0,0,918,116,1,0,0,0,919,920,5,115,0,0,920,921,5,101,0, + 0,921,922,5,108,0,0,922,923,5,101,0,0,923,924,5,99,0,0,924,925,5, + 116,0,0,925,118,1,0,0,0,926,927,5,99,0,0,927,928,5,111,0,0,928,929, + 5,117,0,0,929,930,5,110,0,0,930,931,5,116,0,0,931,120,1,0,0,0,932, + 933,5,102,0,0,933,934,5,114,0,0,934,935,5,111,0,0,935,936,5,109, + 0,0,936,122,1,0,0,0,937,938,5,97,0,0,938,939,5,115,0,0,939,124,1, + 0,0,0,940,941,5,117,0,0,941,942,5,115,0,0,942,943,5,105,0,0,943, + 944,5,110,0,0,944,945,5,103,0,0,945,126,1,0,0,0,946,947,5,115,0, + 0,947,948,5,99,0,0,948,949,5,111,0,0,949,950,5,112,0,0,950,951,5, + 101,0,0,951,128,1,0,0,0,952,953,5,119,0,0,953,954,5,104,0,0,954, + 955,5,101,0,0,955,956,5,114,0,0,956,957,5,101,0,0,957,130,1,0,0, + 0,958,959,5,111,0,0,959,960,5,114,0,0,960,961,5,100,0,0,961,962, + 5,101,0,0,962,963,5,114,0,0,963,132,1,0,0,0,964,965,5,98,0,0,965, + 966,5,121,0,0,966,134,1,0,0,0,967,968,5,108,0,0,968,969,5,105,0, + 0,969,970,5,109,0,0,970,971,5,105,0,0,971,972,5,116,0,0,972,136, + 1,0,0,0,973,974,5,97,0,0,974,975,5,110,0,0,975,976,5,100,0,0,976, + 138,1,0,0,0,977,978,5,111,0,0,978,979,5,114,0,0,979,140,1,0,0,0, + 980,981,5,110,0,0,981,982,5,111,0,0,982,983,5,116,0,0,983,142,1, + 0,0,0,984,985,5,97,0,0,985,986,5,118,0,0,986,987,5,103,0,0,987,144, + 1,0,0,0,988,989,5,99,0,0,989,990,5,111,0,0,990,991,5,117,0,0,991, + 992,5,110,0,0,992,993,5,116,0,0,993,994,5,95,0,0,994,995,5,100,0, + 0,995,996,5,105,0,0,996,997,5,115,0,0,997,998,5,116,0,0,998,999, + 5,105,0,0,999,1000,5,110,0,0,1000,1001,5,99,0,0,1001,1002,5,116, + 0,0,1002,146,1,0,0,0,1003,1004,5,109,0,0,1004,1005,5,105,0,0,1005, + 1006,5,110,0,0,1006,148,1,0,0,0,1007,1008,5,109,0,0,1008,1009,5, + 97,0,0,1009,1010,5,120,0,0,1010,150,1,0,0,0,1011,1012,5,115,0,0, + 1012,1013,5,117,0,0,1013,1014,5,109,0,0,1014,152,1,0,0,0,1015,1016, + 5,116,0,0,1016,1017,5,121,0,0,1017,1018,5,112,0,0,1018,1019,5,101, + 0,0,1019,1020,5,111,0,0,1020,1021,5,102,0,0,1021,154,1,0,0,0,1022, + 1023,5,101,0,0,1023,1024,5,110,0,0,1024,1025,5,100,0,0,1025,156, + 1,0,0,0,1026,1027,5,116,0,0,1027,1028,5,104,0,0,1028,1029,5,101, + 0,0,1029,1030,5,110,0,0,1030,158,1,0,0,0,1031,1032,5,108,0,0,1032, + 1033,5,105,0,0,1033,1034,5,107,0,0,1034,1035,5,101,0,0,1035,160, + 1,0,0,0,1036,1037,5,105,0,0,1037,1038,5,110,0,0,1038,162,1,0,0,0, + 1039,1040,5,105,0,0,1040,1041,5,110,0,0,1041,1042,5,99,0,0,1042, + 1043,5,108,0,0,1043,1044,5,117,0,0,1044,1045,5,100,0,0,1045,1046, + 5,101,0,0,1046,1047,5,115,0,0,1047,164,1,0,0,0,1048,1049,5,101,0, + 0,1049,1050,5,120,0,0,1050,1051,5,99,0,0,1051,1052,5,108,0,0,1052, + 1053,5,117,0,0,1053,1054,5,100,0,0,1054,1055,5,101,0,0,1055,1056, + 5,115,0,0,1056,166,1,0,0,0,1057,1058,5,97,0,0,1058,1059,5,115,0, + 0,1059,1060,5,99,0,0,1060,168,1,0,0,0,1061,1062,5,100,0,0,1062,1063, + 5,101,0,0,1063,1064,5,115,0,0,1064,1065,5,99,0,0,1065,170,1,0,0, + 0,1066,1067,5,110,0,0,1067,1068,5,117,0,0,1068,1069,5,108,0,0,1069, + 1070,5,108,0,0,1070,1071,5,115,0,0,1071,172,1,0,0,0,1072,1073,5, + 102,0,0,1073,1074,5,105,0,0,1074,1075,5,114,0,0,1075,1076,5,115, + 0,0,1076,1077,5,116,0,0,1077,174,1,0,0,0,1078,1079,5,108,0,0,1079, + 1080,5,97,0,0,1080,1081,5,115,0,0,1081,1082,5,116,0,0,1082,176,1, + 0,0,0,1083,1084,5,103,0,0,1084,1085,5,114,0,0,1085,1086,5,111,0, + 0,1086,1087,5,117,0,0,1087,1088,5,112,0,0,1088,178,1,0,0,0,1089, + 1090,5,97,0,0,1090,1091,5,108,0,0,1091,1092,5,108,0,0,1092,180,1, + 0,0,0,1093,1094,5,114,0,0,1094,1095,5,111,0,0,1095,1096,5,119,0, + 0,1096,1097,5,115,0,0,1097,182,1,0,0,0,1098,1099,5,118,0,0,1099, + 1100,5,105,0,0,1100,1101,5,101,0,0,1101,1102,5,119,0,0,1102,184, + 1,0,0,0,1103,1104,5,104,0,0,1104,1105,5,97,0,0,1105,1106,5,118,0, + 0,1106,1107,5,105,0,0,1107,1108,5,110,0,0,1108,1109,5,103,0,0,1109, + 186,1,0,0,0,1110,1111,5,114,0,0,1111,1112,5,111,0,0,1112,1113,5, + 108,0,0,1113,1114,5,108,0,0,1114,1115,5,117,0,0,1115,1116,5,112, + 0,0,1116,188,1,0,0,0,1117,1118,5,116,0,0,1118,1119,5,111,0,0,1119, + 1120,5,108,0,0,1120,1121,5,97,0,0,1121,1122,5,98,0,0,1122,1123,5, + 101,0,0,1123,1124,5,108,0,0,1124,190,1,0,0,0,1125,1126,5,111,0,0, + 1126,1127,5,102,0,0,1127,1128,5,102,0,0,1128,1129,5,115,0,0,1129, + 1130,5,101,0,0,1130,1131,5,116,0,0,1131,192,1,0,0,0,1132,1133,5, + 100,0,0,1133,1134,5,97,0,0,1134,1135,5,116,0,0,1135,1136,5,97,0, + 0,1136,194,1,0,0,0,1137,1138,5,99,0,0,1138,1139,5,97,0,0,1139,1140, + 5,116,0,0,1140,1141,5,101,0,0,1141,1142,5,103,0,0,1142,1143,5,111, + 0,0,1143,1144,5,114,0,0,1144,1145,5,121,0,0,1145,196,1,0,0,0,1146, + 1147,5,97,0,0,1147,1148,5,116,0,0,1148,198,1,0,0,0,1149,1150,5,97, + 0,0,1150,1151,5,98,0,0,1151,1152,5,111,0,0,1152,1153,5,118,0,0,1153, + 1154,5,101,0,0,1154,200,1,0,0,0,1155,1156,5,98,0,0,1156,1157,5,101, + 0,0,1157,1158,5,108,0,0,1158,1159,5,111,0,0,1159,1160,5,119,0,0, + 1160,202,1,0,0,0,1161,1162,5,97,0,0,1162,1163,5,98,0,0,1163,1164, + 5,111,0,0,1164,1165,5,118,0,0,1165,1166,5,101,0,0,1166,1167,5,95, + 0,0,1167,1168,5,111,0,0,1168,1169,5,114,0,0,1169,1170,5,95,0,0,1170, + 1171,5,98,0,0,1171,1172,5,101,0,0,1172,1173,5,108,0,0,1173,1174, + 5,111,0,0,1174,1175,5,119,0,0,1175,204,1,0,0,0,1176,1177,5,115,0, + 0,1177,1178,5,101,0,0,1178,1179,5,99,0,0,1179,1180,5,117,0,0,1180, + 1181,5,114,0,0,1181,1182,5,105,0,0,1182,1183,5,116,0,0,1183,1184, + 5,121,0,0,1184,1185,5,95,0,0,1185,1186,5,101,0,0,1186,1187,5,110, + 0,0,1187,1188,5,102,0,0,1188,1189,5,111,0,0,1189,1190,5,114,0,0, + 1190,1191,5,99,0,0,1191,1192,5,101,0,0,1192,1193,5,100,0,0,1193, + 206,1,0,0,0,1194,1195,5,115,0,0,1195,1196,5,121,0,0,1196,1197,5, + 115,0,0,1197,1198,5,116,0,0,1198,1199,5,101,0,0,1199,1200,5,109, + 0,0,1200,1201,5,95,0,0,1201,1202,5,109,0,0,1202,1203,5,111,0,0,1203, + 1204,5,100,0,0,1204,1205,5,101,0,0,1205,208,1,0,0,0,1206,1207,5, + 117,0,0,1207,1208,5,115,0,0,1208,1209,5,101,0,0,1209,1210,5,114, + 0,0,1210,1211,5,95,0,0,1211,1212,5,109,0,0,1212,1213,5,111,0,0,1213, + 1214,5,100,0,0,1214,1215,5,101,0,0,1215,210,1,0,0,0,1216,1217,5, + 114,0,0,1217,1218,5,101,0,0,1218,1219,5,102,0,0,1219,1220,5,101, + 0,0,1220,1221,5,114,0,0,1221,1222,5,101,0,0,1222,1223,5,110,0,0, + 1223,1224,5,99,0,0,1224,1225,5,101,0,0,1225,212,1,0,0,0,1226,1227, + 5,99,0,0,1227,1228,5,117,0,0,1228,1229,5,98,0,0,1229,1230,5,101, + 0,0,1230,214,1,0,0,0,1231,1232,5,102,0,0,1232,1233,5,111,0,0,1233, + 1234,5,114,0,0,1234,1235,5,109,0,0,1235,1236,5,97,0,0,1236,1237, + 5,116,0,0,1237,216,1,0,0,0,1238,1239,5,116,0,0,1239,1240,5,114,0, + 0,1240,1241,5,97,0,0,1241,1242,5,99,0,0,1242,1243,5,107,0,0,1243, + 1244,5,105,0,0,1244,1245,5,110,0,0,1245,1246,5,103,0,0,1246,218, + 1,0,0,0,1247,1248,5,118,0,0,1248,1249,5,105,0,0,1249,1250,5,101, + 0,0,1250,1251,5,119,0,0,1251,1252,5,115,0,0,1252,1253,5,116,0,0, + 1253,1254,5,97,0,0,1254,1255,5,116,0,0,1255,220,1,0,0,0,1256,1257, + 5,99,0,0,1257,1258,5,117,0,0,1258,1259,5,115,0,0,1259,1260,5,116, + 0,0,1260,1261,5,111,0,0,1261,1262,5,109,0,0,1262,222,1,0,0,0,1263, + 1264,5,115,0,0,1264,1265,5,116,0,0,1265,1266,5,97,0,0,1266,1267, + 5,110,0,0,1267,1268,5,100,0,0,1268,1269,5,97,0,0,1269,1270,5,114, + 0,0,1270,1271,5,100,0,0,1271,224,1,0,0,0,1272,1273,5,100,0,0,1273, + 1274,5,105,0,0,1274,1275,5,115,0,0,1275,1276,5,116,0,0,1276,1277, + 5,97,0,0,1277,1278,5,110,0,0,1278,1279,5,99,0,0,1279,1280,5,101, + 0,0,1280,226,1,0,0,0,1281,1282,5,103,0,0,1282,1283,5,101,0,0,1283, + 1284,5,111,0,0,1284,1285,5,108,0,0,1285,1286,5,111,0,0,1286,1287, + 5,99,0,0,1287,1288,5,97,0,0,1288,1289,5,116,0,0,1289,1290,5,105, + 0,0,1290,1291,5,111,0,0,1291,1292,5,110,0,0,1292,228,1,0,0,0,1293, + 1294,5,99,0,0,1294,1295,5,97,0,0,1295,1296,5,108,0,0,1296,1297,5, + 101,0,0,1297,1298,5,110,0,0,1298,1299,5,100,0,0,1299,1300,5,97,0, + 0,1300,1301,5,114,0,0,1301,1302,5,95,0,0,1302,1303,5,109,0,0,1303, + 1304,5,111,0,0,1304,1305,5,110,0,0,1305,1306,5,116,0,0,1306,1307, + 5,104,0,0,1307,230,1,0,0,0,1308,1309,5,99,0,0,1309,1310,5,97,0,0, + 1310,1311,5,108,0,0,1311,1312,5,101,0,0,1312,1313,5,110,0,0,1313, + 1314,5,100,0,0,1314,1315,5,97,0,0,1315,1316,5,114,0,0,1316,1317, + 5,95,0,0,1317,1318,5,113,0,0,1318,1319,5,117,0,0,1319,1320,5,97, + 0,0,1320,1321,5,114,0,0,1321,1322,5,116,0,0,1322,1323,5,101,0,0, + 1323,1324,5,114,0,0,1324,232,1,0,0,0,1325,1326,5,99,0,0,1326,1327, + 5,97,0,0,1327,1328,5,108,0,0,1328,1329,5,101,0,0,1329,1330,5,110, + 0,0,1330,1331,5,100,0,0,1331,1332,5,97,0,0,1332,1333,5,114,0,0,1333, + 1334,5,95,0,0,1334,1335,5,121,0,0,1335,1336,5,101,0,0,1336,1337, + 5,97,0,0,1337,1338,5,114,0,0,1338,234,1,0,0,0,1339,1340,5,100,0, + 0,1340,1341,5,97,0,0,1341,1342,5,121,0,0,1342,1343,5,95,0,0,1343, + 1344,5,105,0,0,1344,1345,5,110,0,0,1345,1346,5,95,0,0,1346,1347, + 5,109,0,0,1347,1348,5,111,0,0,1348,1349,5,110,0,0,1349,1350,5,116, + 0,0,1350,1351,5,104,0,0,1351,236,1,0,0,0,1352,1353,5,100,0,0,1353, + 1354,5,97,0,0,1354,1355,5,121,0,0,1355,1356,5,95,0,0,1356,1357,5, + 105,0,0,1357,1358,5,110,0,0,1358,1359,5,95,0,0,1359,1360,5,119,0, + 0,1360,1361,5,101,0,0,1361,1362,5,101,0,0,1362,1363,5,107,0,0,1363, + 238,1,0,0,0,1364,1365,5,100,0,0,1365,1366,5,97,0,0,1366,1367,5,121, + 0,0,1367,1368,5,95,0,0,1368,1369,5,105,0,0,1369,1370,5,110,0,0,1370, + 1371,5,95,0,0,1371,1372,5,121,0,0,1372,1373,5,101,0,0,1373,1374, + 5,97,0,0,1374,1375,5,114,0,0,1375,240,1,0,0,0,1376,1377,5,100,0, + 0,1377,1378,5,97,0,0,1378,1379,5,121,0,0,1379,1380,5,95,0,0,1380, + 1381,5,111,0,0,1381,1382,5,110,0,0,1382,1383,5,108,0,0,1383,1384, + 5,121,0,0,1384,242,1,0,0,0,1385,1386,5,102,0,0,1386,1387,5,105,0, + 0,1387,1388,5,115,0,0,1388,1389,5,99,0,0,1389,1390,5,97,0,0,1390, + 1391,5,108,0,0,1391,1392,5,95,0,0,1392,1393,5,109,0,0,1393,1394, + 5,111,0,0,1394,1395,5,110,0,0,1395,1396,5,116,0,0,1396,1397,5,104, + 0,0,1397,244,1,0,0,0,1398,1399,5,102,0,0,1399,1400,5,105,0,0,1400, + 1401,5,115,0,0,1401,1402,5,99,0,0,1402,1403,5,97,0,0,1403,1404,5, + 108,0,0,1404,1405,5,95,0,0,1405,1406,5,113,0,0,1406,1407,5,117,0, + 0,1407,1408,5,97,0,0,1408,1409,5,114,0,0,1409,1410,5,116,0,0,1410, + 1411,5,101,0,0,1411,1412,5,114,0,0,1412,246,1,0,0,0,1413,1414,5, + 102,0,0,1414,1415,5,105,0,0,1415,1416,5,115,0,0,1416,1417,5,99,0, + 0,1417,1418,5,97,0,0,1418,1419,5,108,0,0,1419,1420,5,95,0,0,1420, + 1421,5,121,0,0,1421,1422,5,101,0,0,1422,1423,5,97,0,0,1423,1424, + 5,114,0,0,1424,248,1,0,0,0,1425,1426,5,104,0,0,1426,1427,5,111,0, + 0,1427,1428,5,117,0,0,1428,1429,5,114,0,0,1429,1430,5,95,0,0,1430, + 1431,5,105,0,0,1431,1432,5,110,0,0,1432,1433,5,95,0,0,1433,1434, + 5,100,0,0,1434,1435,5,97,0,0,1435,1436,5,121,0,0,1436,250,1,0,0, + 0,1437,1438,5,119,0,0,1438,1439,5,101,0,0,1439,1440,5,101,0,0,1440, + 1441,5,107,0,0,1441,1442,5,95,0,0,1442,1443,5,105,0,0,1443,1444, + 5,110,0,0,1444,1445,5,95,0,0,1445,1446,5,109,0,0,1446,1447,5,111, + 0,0,1447,1448,5,110,0,0,1448,1449,5,116,0,0,1449,1450,5,104,0,0, + 1450,252,1,0,0,0,1451,1452,5,119,0,0,1452,1453,5,101,0,0,1453,1454, + 5,101,0,0,1454,1455,5,107,0,0,1455,1456,5,95,0,0,1456,1457,5,105, + 0,0,1457,1458,5,110,0,0,1458,1459,5,95,0,0,1459,1460,5,121,0,0,1460, + 1461,5,101,0,0,1461,1462,5,97,0,0,1462,1463,5,114,0,0,1463,254,1, + 0,0,0,1464,1465,5,99,0,0,1465,1466,5,111,0,0,1466,1467,5,110,0,0, + 1467,1468,5,118,0,0,1468,1469,5,101,0,0,1469,1470,5,114,0,0,1470, + 1471,5,116,0,0,1471,1472,5,116,0,0,1472,1473,5,105,0,0,1473,1474, + 5,109,0,0,1474,1475,5,101,0,0,1475,1476,5,122,0,0,1476,1477,5,111, + 0,0,1477,1478,5,110,0,0,1478,1479,5,101,0,0,1479,256,1,0,0,0,1480, + 1481,5,121,0,0,1481,1482,5,101,0,0,1482,1483,5,115,0,0,1483,1484, + 5,116,0,0,1484,1485,5,101,0,0,1485,1486,5,114,0,0,1486,1487,5,100, + 0,0,1487,1488,5,97,0,0,1488,1489,5,121,0,0,1489,258,1,0,0,0,1490, + 1491,5,116,0,0,1491,1492,5,111,0,0,1492,1493,5,100,0,0,1493,1494, + 5,97,0,0,1494,1495,5,121,0,0,1495,260,1,0,0,0,1496,1497,5,116,0, + 0,1497,1498,5,111,0,0,1498,1499,5,109,0,0,1499,1500,5,111,0,0,1500, + 1501,5,114,0,0,1501,1502,5,114,0,0,1502,1503,5,111,0,0,1503,1504, + 5,119,0,0,1504,262,1,0,0,0,1505,1506,5,108,0,0,1506,1507,5,97,0, + 0,1507,1508,5,115,0,0,1508,1509,5,116,0,0,1509,1510,5,95,0,0,1510, + 1511,5,119,0,0,1511,1512,5,101,0,0,1512,1513,5,101,0,0,1513,1514, + 5,107,0,0,1514,264,1,0,0,0,1515,1516,5,116,0,0,1516,1517,5,104,0, + 0,1517,1518,5,105,0,0,1518,1519,5,115,0,0,1519,1520,5,95,0,0,1520, + 1521,5,119,0,0,1521,1522,5,101,0,0,1522,1523,5,101,0,0,1523,1524, + 5,107,0,0,1524,266,1,0,0,0,1525,1526,5,110,0,0,1526,1527,5,101,0, + 0,1527,1528,5,120,0,0,1528,1529,5,116,0,0,1529,1530,5,95,0,0,1530, + 1531,5,119,0,0,1531,1532,5,101,0,0,1532,1533,5,101,0,0,1533,1534, + 5,107,0,0,1534,268,1,0,0,0,1535,1536,5,108,0,0,1536,1537,5,97,0, + 0,1537,1538,5,115,0,0,1538,1539,5,116,0,0,1539,1540,5,95,0,0,1540, + 1541,5,109,0,0,1541,1542,5,111,0,0,1542,1543,5,110,0,0,1543,1544, + 5,116,0,0,1544,1545,5,104,0,0,1545,270,1,0,0,0,1546,1547,5,116,0, + 0,1547,1548,5,104,0,0,1548,1549,5,105,0,0,1549,1550,5,115,0,0,1550, + 1551,5,95,0,0,1551,1552,5,109,0,0,1552,1553,5,111,0,0,1553,1554, + 5,110,0,0,1554,1555,5,116,0,0,1555,1556,5,104,0,0,1556,272,1,0,0, + 0,1557,1558,5,110,0,0,1558,1559,5,101,0,0,1559,1560,5,120,0,0,1560, + 1561,5,116,0,0,1561,1562,5,95,0,0,1562,1563,5,109,0,0,1563,1564, + 5,111,0,0,1564,1565,5,110,0,0,1565,1566,5,116,0,0,1566,1567,5,104, + 0,0,1567,274,1,0,0,0,1568,1569,5,108,0,0,1569,1570,5,97,0,0,1570, + 1571,5,115,0,0,1571,1572,5,116,0,0,1572,1573,5,95,0,0,1573,1574, + 5,57,0,0,1574,1575,5,48,0,0,1575,1576,5,95,0,0,1576,1577,5,100,0, + 0,1577,1578,5,97,0,0,1578,1579,5,121,0,0,1579,1580,5,115,0,0,1580, + 276,1,0,0,0,1581,1582,5,110,0,0,1582,1583,5,101,0,0,1583,1584,5, + 120,0,0,1584,1585,5,116,0,0,1585,1586,5,95,0,0,1586,1587,5,57,0, + 0,1587,1588,5,48,0,0,1588,1589,5,95,0,0,1589,1590,5,100,0,0,1590, + 1591,5,97,0,0,1591,1592,5,121,0,0,1592,1593,5,115,0,0,1593,278,1, + 0,0,0,1594,1595,5,108,0,0,1595,1596,5,97,0,0,1596,1597,5,115,0,0, + 1597,1598,5,116,0,0,1598,1599,5,95,0,0,1599,1600,5,110,0,0,1600, + 1601,5,95,0,0,1601,1602,5,100,0,0,1602,1603,5,97,0,0,1603,1604,5, + 121,0,0,1604,1605,5,115,0,0,1605,280,1,0,0,0,1606,1607,5,110,0,0, + 1607,1608,5,101,0,0,1608,1609,5,120,0,0,1609,1610,5,116,0,0,1610, + 1611,5,95,0,0,1611,1612,5,110,0,0,1612,1613,5,95,0,0,1613,1614,5, + 100,0,0,1614,1615,5,97,0,0,1615,1616,5,121,0,0,1616,1617,5,115,0, + 0,1617,282,1,0,0,0,1618,1619,5,110,0,0,1619,1620,5,95,0,0,1620,1621, + 5,100,0,0,1621,1622,5,97,0,0,1622,1623,5,121,0,0,1623,1624,5,115, + 0,0,1624,1625,5,95,0,0,1625,1626,5,97,0,0,1626,1627,5,103,0,0,1627, + 1628,5,111,0,0,1628,284,1,0,0,0,1629,1630,5,110,0,0,1630,1631,5, + 101,0,0,1631,1632,5,120,0,0,1632,1633,5,116,0,0,1633,1634,5,95,0, + 0,1634,1635,5,110,0,0,1635,1636,5,95,0,0,1636,1637,5,119,0,0,1637, + 1638,5,101,0,0,1638,1639,5,101,0,0,1639,1640,5,107,0,0,1640,1641, + 5,115,0,0,1641,286,1,0,0,0,1642,1643,5,108,0,0,1643,1644,5,97,0, + 0,1644,1645,5,115,0,0,1645,1646,5,116,0,0,1646,1647,5,95,0,0,1647, + 1648,5,110,0,0,1648,1649,5,95,0,0,1649,1650,5,119,0,0,1650,1651, + 5,101,0,0,1651,1652,5,101,0,0,1652,1653,5,107,0,0,1653,1654,5,115, + 0,0,1654,288,1,0,0,0,1655,1656,5,110,0,0,1656,1657,5,95,0,0,1657, + 1658,5,119,0,0,1658,1659,5,101,0,0,1659,1660,5,101,0,0,1660,1661, + 5,107,0,0,1661,1662,5,115,0,0,1662,1663,5,95,0,0,1663,1664,5,97, + 0,0,1664,1665,5,103,0,0,1665,1666,5,111,0,0,1666,290,1,0,0,0,1667, + 1668,5,110,0,0,1668,1669,5,101,0,0,1669,1670,5,120,0,0,1670,1671, + 5,116,0,0,1671,1672,5,95,0,0,1672,1673,5,110,0,0,1673,1674,5,95, + 0,0,1674,1675,5,109,0,0,1675,1676,5,111,0,0,1676,1677,5,110,0,0, + 1677,1678,5,116,0,0,1678,1679,5,104,0,0,1679,1680,5,115,0,0,1680, + 292,1,0,0,0,1681,1682,5,108,0,0,1682,1683,5,97,0,0,1683,1684,5,115, + 0,0,1684,1685,5,116,0,0,1685,1686,5,95,0,0,1686,1687,5,110,0,0,1687, + 1688,5,95,0,0,1688,1689,5,109,0,0,1689,1690,5,111,0,0,1690,1691, + 5,110,0,0,1691,1692,5,116,0,0,1692,1693,5,104,0,0,1693,1694,5,115, + 0,0,1694,294,1,0,0,0,1695,1696,5,110,0,0,1696,1697,5,95,0,0,1697, + 1698,5,109,0,0,1698,1699,5,111,0,0,1699,1700,5,110,0,0,1700,1701, + 5,116,0,0,1701,1702,5,104,0,0,1702,1703,5,115,0,0,1703,1704,5,95, + 0,0,1704,1705,5,97,0,0,1705,1706,5,103,0,0,1706,1707,5,111,0,0,1707, + 296,1,0,0,0,1708,1709,5,116,0,0,1709,1710,5,104,0,0,1710,1711,5, + 105,0,0,1711,1712,5,115,0,0,1712,1713,5,95,0,0,1713,1714,5,113,0, + 0,1714,1715,5,117,0,0,1715,1716,5,97,0,0,1716,1717,5,114,0,0,1717, + 1718,5,116,0,0,1718,1719,5,101,0,0,1719,1720,5,114,0,0,1720,298, + 1,0,0,0,1721,1722,5,108,0,0,1722,1723,5,97,0,0,1723,1724,5,115,0, + 0,1724,1725,5,116,0,0,1725,1726,5,95,0,0,1726,1727,5,113,0,0,1727, + 1728,5,117,0,0,1728,1729,5,97,0,0,1729,1730,5,114,0,0,1730,1731, + 5,116,0,0,1731,1732,5,101,0,0,1732,1733,5,114,0,0,1733,300,1,0,0, + 0,1734,1735,5,110,0,0,1735,1736,5,101,0,0,1736,1737,5,120,0,0,1737, + 1738,5,116,0,0,1738,1739,5,95,0,0,1739,1740,5,113,0,0,1740,1741, + 5,117,0,0,1741,1742,5,97,0,0,1742,1743,5,114,0,0,1743,1744,5,116, + 0,0,1744,1745,5,101,0,0,1745,1746,5,114,0,0,1746,302,1,0,0,0,1747, + 1748,5,110,0,0,1748,1749,5,101,0,0,1749,1750,5,120,0,0,1750,1751, + 5,116,0,0,1751,1752,5,95,0,0,1752,1753,5,110,0,0,1753,1754,5,95, + 0,0,1754,1755,5,113,0,0,1755,1756,5,117,0,0,1756,1757,5,97,0,0,1757, + 1758,5,114,0,0,1758,1759,5,116,0,0,1759,1760,5,101,0,0,1760,1761, + 5,114,0,0,1761,1762,5,115,0,0,1762,304,1,0,0,0,1763,1764,5,108,0, + 0,1764,1765,5,97,0,0,1765,1766,5,115,0,0,1766,1767,5,116,0,0,1767, + 1768,5,95,0,0,1768,1769,5,110,0,0,1769,1770,5,95,0,0,1770,1771,5, + 113,0,0,1771,1772,5,117,0,0,1772,1773,5,97,0,0,1773,1774,5,114,0, + 0,1774,1775,5,116,0,0,1775,1776,5,101,0,0,1776,1777,5,114,0,0,1777, + 1778,5,115,0,0,1778,306,1,0,0,0,1779,1780,5,110,0,0,1780,1781,5, + 95,0,0,1781,1782,5,113,0,0,1782,1783,5,117,0,0,1783,1784,5,97,0, + 0,1784,1785,5,114,0,0,1785,1786,5,116,0,0,1786,1787,5,101,0,0,1787, + 1788,5,114,0,0,1788,1789,5,115,0,0,1789,1790,5,95,0,0,1790,1791, + 5,97,0,0,1791,1792,5,103,0,0,1792,1793,5,111,0,0,1793,308,1,0,0, + 0,1794,1795,5,116,0,0,1795,1796,5,104,0,0,1796,1797,5,105,0,0,1797, + 1798,5,115,0,0,1798,1799,5,95,0,0,1799,1800,5,121,0,0,1800,1801, + 5,101,0,0,1801,1802,5,97,0,0,1802,1803,5,114,0,0,1803,310,1,0,0, + 0,1804,1805,5,108,0,0,1805,1806,5,97,0,0,1806,1807,5,115,0,0,1807, + 1808,5,116,0,0,1808,1809,5,95,0,0,1809,1810,5,121,0,0,1810,1811, + 5,101,0,0,1811,1812,5,97,0,0,1812,1813,5,114,0,0,1813,312,1,0,0, + 0,1814,1815,5,110,0,0,1815,1816,5,101,0,0,1816,1817,5,120,0,0,1817, + 1818,5,116,0,0,1818,1819,5,95,0,0,1819,1820,5,121,0,0,1820,1821, + 5,101,0,0,1821,1822,5,97,0,0,1822,1823,5,114,0,0,1823,314,1,0,0, + 0,1824,1825,5,110,0,0,1825,1826,5,101,0,0,1826,1827,5,120,0,0,1827, + 1828,5,116,0,0,1828,1829,5,95,0,0,1829,1830,5,110,0,0,1830,1831, + 5,95,0,0,1831,1832,5,121,0,0,1832,1833,5,101,0,0,1833,1834,5,97, + 0,0,1834,1835,5,114,0,0,1835,1836,5,115,0,0,1836,316,1,0,0,0,1837, + 1838,5,108,0,0,1838,1839,5,97,0,0,1839,1840,5,115,0,0,1840,1841, + 5,116,0,0,1841,1842,5,95,0,0,1842,1843,5,110,0,0,1843,1844,5,95, + 0,0,1844,1845,5,121,0,0,1845,1846,5,101,0,0,1846,1847,5,97,0,0,1847, + 1848,5,114,0,0,1848,1849,5,115,0,0,1849,318,1,0,0,0,1850,1851,5, + 110,0,0,1851,1852,5,95,0,0,1852,1853,5,121,0,0,1853,1854,5,101,0, + 0,1854,1855,5,97,0,0,1855,1856,5,114,0,0,1856,1857,5,115,0,0,1857, + 1858,5,95,0,0,1858,1859,5,97,0,0,1859,1860,5,103,0,0,1860,1861,5, + 111,0,0,1861,320,1,0,0,0,1862,1863,5,116,0,0,1863,1864,5,104,0,0, + 1864,1865,5,105,0,0,1865,1866,5,115,0,0,1866,1867,5,95,0,0,1867, + 1868,5,102,0,0,1868,1869,5,105,0,0,1869,1870,5,115,0,0,1870,1871, + 5,99,0,0,1871,1872,5,97,0,0,1872,1873,5,108,0,0,1873,1874,5,95,0, + 0,1874,1875,5,113,0,0,1875,1876,5,117,0,0,1876,1877,5,97,0,0,1877, + 1878,5,114,0,0,1878,1879,5,116,0,0,1879,1880,5,101,0,0,1880,1881, + 5,114,0,0,1881,322,1,0,0,0,1882,1883,5,108,0,0,1883,1884,5,97,0, + 0,1884,1885,5,115,0,0,1885,1886,5,116,0,0,1886,1887,5,95,0,0,1887, + 1888,5,102,0,0,1888,1889,5,105,0,0,1889,1890,5,115,0,0,1890,1891, + 5,99,0,0,1891,1892,5,97,0,0,1892,1893,5,108,0,0,1893,1894,5,95,0, + 0,1894,1895,5,113,0,0,1895,1896,5,117,0,0,1896,1897,5,97,0,0,1897, + 1898,5,114,0,0,1898,1899,5,116,0,0,1899,1900,5,101,0,0,1900,1901, + 5,114,0,0,1901,324,1,0,0,0,1902,1903,5,110,0,0,1903,1904,5,101,0, + 0,1904,1905,5,120,0,0,1905,1906,5,116,0,0,1906,1907,5,95,0,0,1907, + 1908,5,102,0,0,1908,1909,5,105,0,0,1909,1910,5,115,0,0,1910,1911, + 5,99,0,0,1911,1912,5,97,0,0,1912,1913,5,108,0,0,1913,1914,5,95,0, + 0,1914,1915,5,113,0,0,1915,1916,5,117,0,0,1916,1917,5,97,0,0,1917, + 1918,5,114,0,0,1918,1919,5,116,0,0,1919,1920,5,101,0,0,1920,1921, + 5,114,0,0,1921,326,1,0,0,0,1922,1923,5,110,0,0,1923,1924,5,101,0, + 0,1924,1925,5,120,0,0,1925,1926,5,116,0,0,1926,1927,5,95,0,0,1927, + 1928,5,110,0,0,1928,1929,5,95,0,0,1929,1930,5,102,0,0,1930,1931, + 5,105,0,0,1931,1932,5,115,0,0,1932,1933,5,99,0,0,1933,1934,5,97, + 0,0,1934,1935,5,108,0,0,1935,1936,5,95,0,0,1936,1937,5,113,0,0,1937, + 1938,5,117,0,0,1938,1939,5,97,0,0,1939,1940,5,114,0,0,1940,1941, + 5,116,0,0,1941,1942,5,101,0,0,1942,1943,5,114,0,0,1943,1944,5,115, + 0,0,1944,328,1,0,0,0,1945,1946,5,108,0,0,1946,1947,5,97,0,0,1947, + 1948,5,115,0,0,1948,1949,5,116,0,0,1949,1950,5,95,0,0,1950,1951, + 5,110,0,0,1951,1952,5,95,0,0,1952,1953,5,102,0,0,1953,1954,5,105, + 0,0,1954,1955,5,115,0,0,1955,1956,5,99,0,0,1956,1957,5,97,0,0,1957, + 1958,5,108,0,0,1958,1959,5,95,0,0,1959,1960,5,113,0,0,1960,1961, + 5,117,0,0,1961,1962,5,97,0,0,1962,1963,5,114,0,0,1963,1964,5,116, + 0,0,1964,1965,5,101,0,0,1965,1966,5,114,0,0,1966,1967,5,115,0,0, + 1967,330,1,0,0,0,1968,1969,5,110,0,0,1969,1970,5,95,0,0,1970,1971, + 5,102,0,0,1971,1972,5,105,0,0,1972,1973,5,115,0,0,1973,1974,5,99, + 0,0,1974,1975,5,97,0,0,1975,1976,5,108,0,0,1976,1977,5,95,0,0,1977, + 1978,5,113,0,0,1978,1979,5,117,0,0,1979,1980,5,97,0,0,1980,1981, + 5,114,0,0,1981,1982,5,116,0,0,1982,1983,5,101,0,0,1983,1984,5,114, + 0,0,1984,1985,5,115,0,0,1985,1986,5,95,0,0,1986,1987,5,97,0,0,1987, + 1988,5,103,0,0,1988,1989,5,111,0,0,1989,332,1,0,0,0,1990,1991,5, + 116,0,0,1991,1992,5,104,0,0,1992,1993,5,105,0,0,1993,1994,5,115, + 0,0,1994,1995,5,95,0,0,1995,1996,5,102,0,0,1996,1997,5,105,0,0,1997, + 1998,5,115,0,0,1998,1999,5,99,0,0,1999,2000,5,97,0,0,2000,2001,5, + 108,0,0,2001,2002,5,95,0,0,2002,2003,5,121,0,0,2003,2004,5,101,0, + 0,2004,2005,5,97,0,0,2005,2006,5,114,0,0,2006,334,1,0,0,0,2007,2008, + 5,108,0,0,2008,2009,5,97,0,0,2009,2010,5,115,0,0,2010,2011,5,116, + 0,0,2011,2012,5,95,0,0,2012,2013,5,102,0,0,2013,2014,5,105,0,0,2014, + 2015,5,115,0,0,2015,2016,5,99,0,0,2016,2017,5,97,0,0,2017,2018,5, + 108,0,0,2018,2019,5,95,0,0,2019,2020,5,121,0,0,2020,2021,5,101,0, + 0,2021,2022,5,97,0,0,2022,2023,5,114,0,0,2023,336,1,0,0,0,2024,2025, + 5,110,0,0,2025,2026,5,101,0,0,2026,2027,5,120,0,0,2027,2028,5,116, + 0,0,2028,2029,5,95,0,0,2029,2030,5,102,0,0,2030,2031,5,105,0,0,2031, + 2032,5,115,0,0,2032,2033,5,99,0,0,2033,2034,5,97,0,0,2034,2035,5, + 108,0,0,2035,2036,5,95,0,0,2036,2037,5,121,0,0,2037,2038,5,101,0, + 0,2038,2039,5,97,0,0,2039,2040,5,114,0,0,2040,338,1,0,0,0,2041,2042, + 5,110,0,0,2042,2043,5,101,0,0,2043,2044,5,120,0,0,2044,2045,5,116, + 0,0,2045,2046,5,95,0,0,2046,2047,5,110,0,0,2047,2048,5,95,0,0,2048, + 2049,5,102,0,0,2049,2050,5,105,0,0,2050,2051,5,115,0,0,2051,2052, + 5,99,0,0,2052,2053,5,97,0,0,2053,2054,5,108,0,0,2054,2055,5,95,0, + 0,2055,2056,5,121,0,0,2056,2057,5,101,0,0,2057,2058,5,97,0,0,2058, + 2059,5,114,0,0,2059,2060,5,115,0,0,2060,340,1,0,0,0,2061,2062,5, + 108,0,0,2062,2063,5,97,0,0,2063,2064,5,115,0,0,2064,2065,5,116,0, + 0,2065,2066,5,95,0,0,2066,2067,5,110,0,0,2067,2068,5,95,0,0,2068, + 2069,5,102,0,0,2069,2070,5,105,0,0,2070,2071,5,115,0,0,2071,2072, + 5,99,0,0,2072,2073,5,97,0,0,2073,2074,5,108,0,0,2074,2075,5,95,0, + 0,2075,2076,5,121,0,0,2076,2077,5,101,0,0,2077,2078,5,97,0,0,2078, + 2079,5,114,0,0,2079,2080,5,115,0,0,2080,342,1,0,0,0,2081,2082,5, + 110,0,0,2082,2083,5,95,0,0,2083,2084,5,102,0,0,2084,2085,5,105,0, + 0,2085,2086,5,115,0,0,2086,2087,5,99,0,0,2087,2088,5,97,0,0,2088, + 2089,5,108,0,0,2089,2090,5,95,0,0,2090,2091,5,121,0,0,2091,2092, + 5,101,0,0,2092,2093,5,97,0,0,2093,2094,5,114,0,0,2094,2095,5,115, + 0,0,2095,2096,5,95,0,0,2096,2097,5,97,0,0,2097,2098,5,103,0,0,2098, + 2099,5,111,0,0,2099,344,1,0,0,0,2100,2101,3,401,200,0,2101,2102, + 3,401,200,0,2102,2103,3,401,200,0,2103,2104,3,401,200,0,2104,2105, + 5,45,0,0,2105,2106,3,401,200,0,2106,2107,3,401,200,0,2107,2108,5, + 45,0,0,2108,2109,3,401,200,0,2109,2110,3,401,200,0,2110,346,1,0, + 0,0,2111,2112,3,345,172,0,2112,2113,5,116,0,0,2113,2114,3,401,200, + 0,2114,2115,3,401,200,0,2115,2116,5,58,0,0,2116,2117,3,401,200,0, + 2117,2118,3,401,200,0,2118,2119,5,58,0,0,2119,2120,3,401,200,0,2120, + 2136,3,401,200,0,2121,2137,5,122,0,0,2122,2124,7,0,0,0,2123,2125, + 3,401,200,0,2124,2123,1,0,0,0,2125,2126,1,0,0,0,2126,2124,1,0,0, + 0,2126,2127,1,0,0,0,2127,2134,1,0,0,0,2128,2130,5,58,0,0,2129,2131, + 3,401,200,0,2130,2129,1,0,0,0,2131,2132,1,0,0,0,2132,2130,1,0,0, + 0,2132,2133,1,0,0,0,2133,2135,1,0,0,0,2134,2128,1,0,0,0,2134,2135, + 1,0,0,0,2135,2137,1,0,0,0,2136,2121,1,0,0,0,2136,2122,1,0,0,0,2137, + 348,1,0,0,0,2138,2139,7,1,0,0,2139,2140,7,1,0,0,2140,2142,7,1,0, + 0,2141,2143,3,401,200,0,2142,2141,1,0,0,0,2143,2144,1,0,0,0,2144, + 2142,1,0,0,0,2144,2145,1,0,0,0,2145,350,1,0,0,0,2146,2147,5,102, + 0,0,2147,2148,5,105,0,0,2148,2149,5,110,0,0,2149,2150,5,100,0,0, + 2150,352,1,0,0,0,2151,2152,5,101,0,0,2152,2153,5,109,0,0,2153,2154, + 5,97,0,0,2154,2155,5,105,0,0,2155,2156,5,108,0,0,2156,354,1,0,0, + 0,2157,2158,5,110,0,0,2158,2159,5,97,0,0,2159,2160,5,109,0,0,2160, + 2161,5,101,0,0,2161,356,1,0,0,0,2162,2163,5,112,0,0,2163,2164,5, + 104,0,0,2164,2165,5,111,0,0,2165,2166,5,110,0,0,2166,2167,5,101, + 0,0,2167,358,1,0,0,0,2168,2169,5,115,0,0,2169,2170,5,105,0,0,2170, + 2171,5,100,0,0,2171,2172,5,101,0,0,2172,2173,5,98,0,0,2173,2174, + 5,97,0,0,2174,2175,5,114,0,0,2175,360,1,0,0,0,2176,2177,5,102,0, + 0,2177,2178,5,105,0,0,2178,2179,5,101,0,0,2179,2180,5,108,0,0,2180, + 2181,5,100,0,0,2181,2182,5,115,0,0,2182,362,1,0,0,0,2183,2184,5, + 109,0,0,2184,2185,5,101,0,0,2185,2186,5,116,0,0,2186,2187,5,97,0, + 0,2187,2188,5,100,0,0,2188,2189,5,97,0,0,2189,2190,5,116,0,0,2190, + 2191,5,97,0,0,2191,364,1,0,0,0,2192,2193,5,112,0,0,2193,2194,5,114, + 0,0,2194,2195,5,105,0,0,2195,2196,5,99,0,0,2196,2197,5,101,0,0,2197, + 2198,5,98,0,0,2198,2199,5,111,0,0,2199,2200,5,111,0,0,2200,2201, + 5,107,0,0,2201,2202,5,105,0,0,2202,2203,5,100,0,0,2203,366,1,0,0, + 0,2204,2205,5,110,0,0,2205,2206,5,101,0,0,2206,2207,5,116,0,0,2207, + 2208,5,119,0,0,2208,2209,5,111,0,0,2209,2210,5,114,0,0,2210,2211, + 5,107,0,0,2211,368,1,0,0,0,2212,2213,5,115,0,0,2213,2214,5,110,0, + 0,2214,2215,5,105,0,0,2215,2216,5,112,0,0,2216,2217,5,112,0,0,2217, + 2218,5,101,0,0,2218,2219,5,116,0,0,2219,370,1,0,0,0,2220,2221,5, + 116,0,0,2221,2222,5,97,0,0,2222,2223,5,114,0,0,2223,2224,5,103,0, + 0,2224,2225,5,101,0,0,2225,2226,5,116,0,0,2226,2227,5,95,0,0,2227, + 2228,5,108,0,0,2228,2229,5,101,0,0,2229,2230,5,110,0,0,2230,2231, + 5,103,0,0,2231,2232,5,116,0,0,2232,2233,5,104,0,0,2233,372,1,0,0, + 0,2234,2235,5,100,0,0,2235,2236,5,105,0,0,2236,2237,5,118,0,0,2237, + 2238,5,105,0,0,2238,2239,5,115,0,0,2239,2240,5,105,0,0,2240,2241, + 5,111,0,0,2241,2242,5,110,0,0,2242,374,1,0,0,0,2243,2244,5,114,0, + 0,2244,2245,5,101,0,0,2245,2246,5,116,0,0,2246,2247,5,117,0,0,2247, + 2248,5,114,0,0,2248,2249,5,110,0,0,2249,2250,5,105,0,0,2250,2251, + 5,110,0,0,2251,2252,5,103,0,0,2252,376,1,0,0,0,2253,2254,5,108,0, + 0,2254,2255,5,105,0,0,2255,2256,5,115,0,0,2256,2257,5,116,0,0,2257, + 2258,5,118,0,0,2258,2259,5,105,0,0,2259,2260,5,101,0,0,2260,2261, + 5,119,0,0,2261,378,1,0,0,0,2262,2264,5,91,0,0,2263,2265,3,513,256, + 0,2264,2263,1,0,0,0,2264,2265,1,0,0,0,2265,2266,1,0,0,0,2266,2267, + 5,102,0,0,2267,2268,5,105,0,0,2268,2269,5,110,0,0,2269,2270,5,100, + 0,0,2270,2271,1,0,0,0,2271,2272,3,513,256,0,2272,2274,5,39,0,0,2273, + 2275,3,381,190,0,2274,2273,1,0,0,0,2274,2275,1,0,0,0,2275,2276,1, + 0,0,0,2276,2277,5,39,0,0,2277,380,1,0,0,0,2278,2280,3,383,191,0, + 2279,2278,1,0,0,0,2280,2281,1,0,0,0,2281,2279,1,0,0,0,2281,2282, + 1,0,0,0,2282,382,1,0,0,0,2283,2286,8,2,0,0,2284,2286,3,391,195,0, + 2285,2283,1,0,0,0,2285,2284,1,0,0,0,2286,384,1,0,0,0,2287,2289,5, + 91,0,0,2288,2290,3,513,256,0,2289,2288,1,0,0,0,2289,2290,1,0,0,0, + 2290,2291,1,0,0,0,2291,2292,5,102,0,0,2292,2293,5,105,0,0,2293,2294, + 5,110,0,0,2294,2295,5,100,0,0,2295,2296,1,0,0,0,2296,2297,3,513, + 256,0,2297,2299,5,123,0,0,2298,2300,3,387,193,0,2299,2298,1,0,0, + 0,2299,2300,1,0,0,0,2300,2301,1,0,0,0,2301,2302,5,125,0,0,2302,386, + 1,0,0,0,2303,2305,3,389,194,0,2304,2303,1,0,0,0,2305,2306,1,0,0, + 0,2306,2304,1,0,0,0,2306,2307,1,0,0,0,2307,388,1,0,0,0,2308,2311, + 8,3,0,0,2309,2311,3,391,195,0,2310,2308,1,0,0,0,2310,2309,1,0,0, + 0,2311,390,1,0,0,0,2312,2313,5,92,0,0,2313,2314,7,4,0,0,2314,392, + 1,0,0,0,2315,2319,3,401,200,0,2316,2318,3,401,200,0,2317,2316,1, + 0,0,0,2318,2321,1,0,0,0,2319,2317,1,0,0,0,2319,2320,1,0,0,0,2320, + 394,1,0,0,0,2321,2319,1,0,0,0,2322,2326,3,401,200,0,2323,2325,3, + 401,200,0,2324,2323,1,0,0,0,2325,2328,1,0,0,0,2326,2324,1,0,0,0, + 2326,2327,1,0,0,0,2327,2329,1,0,0,0,2328,2326,1,0,0,0,2329,2330, + 7,5,0,0,2330,396,1,0,0,0,2331,2333,3,401,200,0,2332,2331,1,0,0,0, + 2333,2336,1,0,0,0,2334,2332,1,0,0,0,2334,2335,1,0,0,0,2335,2337, + 1,0,0,0,2336,2334,1,0,0,0,2337,2338,5,46,0,0,2338,2342,3,401,200, + 0,2339,2341,3,401,200,0,2340,2339,1,0,0,0,2341,2344,1,0,0,0,2342, + 2340,1,0,0,0,2342,2343,1,0,0,0,2343,2346,1,0,0,0,2344,2342,1,0,0, + 0,2345,2347,7,6,0,0,2346,2345,1,0,0,0,2346,2347,1,0,0,0,2347,398, + 1,0,0,0,2348,2351,3,401,200,0,2349,2351,2,97,102,0,2350,2348,1,0, + 0,0,2350,2349,1,0,0,0,2351,400,1,0,0,0,2352,2353,7,7,0,0,2353,402, + 1,0,0,0,2354,2355,5,116,0,0,2355,2356,5,114,0,0,2356,2357,5,117, + 0,0,2357,2364,5,101,0,0,2358,2359,5,102,0,0,2359,2360,5,97,0,0,2360, + 2361,5,108,0,0,2361,2362,5,115,0,0,2362,2364,5,101,0,0,2363,2354, + 1,0,0,0,2363,2358,1,0,0,0,2364,404,1,0,0,0,2365,2367,5,39,0,0,2366, + 2368,3,407,203,0,2367,2366,1,0,0,0,2367,2368,1,0,0,0,2368,2369,1, + 0,0,0,2369,2370,5,39,0,0,2370,406,1,0,0,0,2371,2373,3,409,204,0, + 2372,2371,1,0,0,0,2373,2374,1,0,0,0,2374,2372,1,0,0,0,2374,2375, + 1,0,0,0,2375,408,1,0,0,0,2376,2379,8,2,0,0,2377,2379,3,411,205,0, + 2378,2376,1,0,0,0,2378,2377,1,0,0,0,2379,410,1,0,0,0,2380,2381,5, + 92,0,0,2381,2391,7,8,0,0,2382,2383,5,92,0,0,2383,2384,5,117,0,0, + 2384,2385,1,0,0,0,2385,2386,3,399,199,0,2386,2387,3,399,199,0,2387, + 2388,3,399,199,0,2388,2389,3,399,199,0,2389,2391,1,0,0,0,2390,2380, + 1,0,0,0,2390,2382,1,0,0,0,2391,412,1,0,0,0,2392,2393,3,51,25,0,2393, + 414,1,0,0,0,2394,2395,5,40,0,0,2395,416,1,0,0,0,2396,2397,5,41,0, + 0,2397,418,1,0,0,0,2398,2399,5,123,0,0,2399,420,1,0,0,0,2400,2401, + 5,125,0,0,2401,422,1,0,0,0,2402,2403,5,91,0,0,2403,424,1,0,0,0,2404, + 2405,5,93,0,0,2405,426,1,0,0,0,2406,2407,5,59,0,0,2407,428,1,0,0, + 0,2408,2409,5,44,0,0,2409,430,1,0,0,0,2410,2411,5,46,0,0,2411,432, + 1,0,0,0,2412,2413,5,61,0,0,2413,434,1,0,0,0,2414,2415,5,62,0,0,2415, + 436,1,0,0,0,2416,2417,5,60,0,0,2417,438,1,0,0,0,2418,2419,5,33,0, + 0,2419,440,1,0,0,0,2420,2421,5,126,0,0,2421,442,1,0,0,0,2422,2423, + 5,63,0,0,2423,2424,5,46,0,0,2424,444,1,0,0,0,2425,2426,5,63,0,0, + 2426,446,1,0,0,0,2427,2428,5,63,0,0,2428,2429,5,63,0,0,2429,448, + 1,0,0,0,2430,2431,5,58,0,0,2431,450,1,0,0,0,2432,2433,5,61,0,0,2433, + 2434,5,61,0,0,2434,452,1,0,0,0,2435,2436,5,61,0,0,2436,2437,5,61, + 0,0,2437,2438,5,61,0,0,2438,454,1,0,0,0,2439,2440,5,33,0,0,2440, + 2441,5,61,0,0,2441,456,1,0,0,0,2442,2443,5,60,0,0,2443,2444,5,62, + 0,0,2444,458,1,0,0,0,2445,2446,5,33,0,0,2446,2447,5,61,0,0,2447, + 2448,5,61,0,0,2448,460,1,0,0,0,2449,2450,5,38,0,0,2450,2451,5,38, + 0,0,2451,462,1,0,0,0,2452,2453,5,124,0,0,2453,2454,5,124,0,0,2454, + 464,1,0,0,0,2455,2456,5,43,0,0,2456,2457,5,43,0,0,2457,466,1,0,0, + 0,2458,2459,5,45,0,0,2459,2460,5,45,0,0,2460,468,1,0,0,0,2461,2462, + 5,43,0,0,2462,470,1,0,0,0,2463,2464,5,45,0,0,2464,472,1,0,0,0,2465, + 2466,5,42,0,0,2466,474,1,0,0,0,2467,2468,5,47,0,0,2468,476,1,0,0, + 0,2469,2470,5,38,0,0,2470,478,1,0,0,0,2471,2472,5,124,0,0,2472,480, + 1,0,0,0,2473,2474,5,94,0,0,2474,482,1,0,0,0,2475,2476,5,61,0,0,2476, + 2477,5,62,0,0,2477,484,1,0,0,0,2478,2479,5,43,0,0,2479,2480,5,61, + 0,0,2480,486,1,0,0,0,2481,2482,5,45,0,0,2482,2483,5,61,0,0,2483, + 488,1,0,0,0,2484,2485,5,42,0,0,2485,2486,5,61,0,0,2486,490,1,0,0, + 0,2487,2488,5,47,0,0,2488,2489,5,61,0,0,2489,492,1,0,0,0,2490,2491, + 5,38,0,0,2491,2492,5,61,0,0,2492,494,1,0,0,0,2493,2494,5,124,0,0, + 2494,2495,5,61,0,0,2495,496,1,0,0,0,2496,2497,5,94,0,0,2497,2498, + 5,61,0,0,2498,498,1,0,0,0,2499,2500,5,60,0,0,2500,2501,5,60,0,0, + 2501,2502,5,61,0,0,2502,500,1,0,0,0,2503,2504,5,62,0,0,2504,2505, + 5,62,0,0,2505,2506,5,61,0,0,2506,502,1,0,0,0,2507,2508,5,62,0,0, + 2508,2509,5,62,0,0,2509,2510,5,62,0,0,2510,2511,5,61,0,0,2511,504, + 1,0,0,0,2512,2513,5,64,0,0,2513,506,1,0,0,0,2514,2518,3,509,254, + 0,2515,2517,3,511,255,0,2516,2515,1,0,0,0,2517,2520,1,0,0,0,2518, + 2516,1,0,0,0,2518,2519,1,0,0,0,2519,508,1,0,0,0,2520,2518,1,0,0, + 0,2521,2526,7,9,0,0,2522,2526,8,10,0,0,2523,2524,7,11,0,0,2524,2526, + 7,12,0,0,2525,2521,1,0,0,0,2525,2522,1,0,0,0,2525,2523,1,0,0,0,2526, + 510,1,0,0,0,2527,2532,7,13,0,0,2528,2532,8,10,0,0,2529,2530,7,11, + 0,0,2530,2532,7,12,0,0,2531,2527,1,0,0,0,2531,2528,1,0,0,0,2531, + 2529,1,0,0,0,2532,512,1,0,0,0,2533,2535,7,14,0,0,2534,2533,1,0,0, + 0,2535,2536,1,0,0,0,2536,2534,1,0,0,0,2536,2537,1,0,0,0,2537,2538, + 1,0,0,0,2538,2539,6,256,0,0,2539,514,1,0,0,0,2540,2541,5,47,0,0, + 2541,2542,5,42,0,0,2542,2543,5,42,0,0,2543,2547,1,0,0,0,2544,2546, + 9,0,0,0,2545,2544,1,0,0,0,2546,2549,1,0,0,0,2547,2548,1,0,0,0,2547, + 2545,1,0,0,0,2548,2550,1,0,0,0,2549,2547,1,0,0,0,2550,2551,5,42, + 0,0,2551,2552,5,47,0,0,2552,2553,1,0,0,0,2553,2554,6,257,1,0,2554, + 516,1,0,0,0,2555,2556,5,47,0,0,2556,2557,5,42,0,0,2557,2561,1,0, + 0,0,2558,2560,9,0,0,0,2559,2558,1,0,0,0,2560,2563,1,0,0,0,2561,2562, + 1,0,0,0,2561,2559,1,0,0,0,2562,2564,1,0,0,0,2563,2561,1,0,0,0,2564, + 2565,5,42,0,0,2565,2566,5,47,0,0,2566,2567,1,0,0,0,2567,2568,6,258, + 1,0,2568,518,1,0,0,0,2569,2570,5,47,0,0,2570,2571,5,47,0,0,2571, + 2575,1,0,0,0,2572,2574,8,15,0,0,2573,2572,1,0,0,0,2574,2577,1,0, + 0,0,2575,2573,1,0,0,0,2575,2576,1,0,0,0,2576,2578,1,0,0,0,2577,2575, + 1,0,0,0,2578,2579,6,259,1,0,2579,520,1,0,0,0,32,0,2126,2132,2134, + 2136,2144,2264,2274,2281,2285,2289,2299,2306,2310,2319,2326,2334, + 2342,2346,2350,2363,2367,2374,2378,2390,2518,2525,2531,2536,2547, + 2561,2575,2,0,2,0,0,3,0 + ]; + + private static __ATN: antlr.ATN; + public static get _ATN(): antlr.ATN { + if (!ApexLexer.__ATN) { + ApexLexer.__ATN = new antlr.ATNDeserializer().deserialize(ApexLexer._serializedATN); + } + + return ApexLexer.__ATN; + } + + + private static readonly vocabulary = new antlr.Vocabulary(ApexLexer.literalNames, ApexLexer.symbolicNames, []); + + public override get vocabulary(): antlr.Vocabulary { + return ApexLexer.vocabulary; + } + + private static readonly decisionsToDFA = ApexLexer._ATN.decisionToState.map( (ds: antlr.DecisionState, index: number) => new antlr.DFA(ds, index) ); +} \ No newline at end of file diff --git a/packages/apex/src/grammar/ApexParser.ts b/packages/apex/src/grammar/ApexParser.ts new file mode 100644 index 00000000..bf258862 --- /dev/null +++ b/packages/apex/src/grammar/ApexParser.ts @@ -0,0 +1,19537 @@ +// Generated from ./grammar/ApexParser.g4 by ANTLR 4.13.1 + +import * as antlr from "antlr4ng"; +import { Token } from "antlr4ng"; + +import { ApexParserListener } from "./ApexParserListener.js"; +import { ApexParserVisitor } from "./ApexParserVisitor.js"; + +// for running tests with parameters, TODO: discuss strategy for typed parameters in CI +// eslint-disable-next-line no-unused-vars +type int = number; + + +export class ApexParser extends antlr.Parser { + public static readonly ABSTRACT = 1; + public static readonly AFTER = 2; + public static readonly BEFORE = 3; + public static readonly BREAK = 4; + public static readonly CATCH = 5; + public static readonly CLASS = 6; + public static readonly CONTINUE = 7; + public static readonly DELETE = 8; + public static readonly DO = 9; + public static readonly ELSE = 10; + public static readonly ENUM = 11; + public static readonly EXTENDS = 12; + public static readonly FINAL = 13; + public static readonly FINALLY = 14; + public static readonly FOR = 15; + public static readonly GET = 16; + public static readonly GLOBAL = 17; + public static readonly IF = 18; + public static readonly IMPLEMENTS = 19; + public static readonly INHERITED = 20; + public static readonly INSERT = 21; + public static readonly INSTANCEOF = 22; + public static readonly INTERFACE = 23; + public static readonly MERGE = 24; + public static readonly NEW = 25; + public static readonly NULL = 26; + public static readonly ON = 27; + public static readonly OVERRIDE = 28; + public static readonly PRIVATE = 29; + public static readonly PROTECTED = 30; + public static readonly PUBLIC = 31; + public static readonly RETURN = 32; + public static readonly SYSTEMRUNAS = 33; + public static readonly SET = 34; + public static readonly SHARING = 35; + public static readonly STATIC = 36; + public static readonly SUPER = 37; + public static readonly SWITCH = 38; + public static readonly TESTMETHOD = 39; + public static readonly THIS = 40; + public static readonly THROW = 41; + public static readonly TRANSIENT = 42; + public static readonly TRIGGER = 43; + public static readonly TRY = 44; + public static readonly UNDELETE = 45; + public static readonly UPDATE = 46; + public static readonly UPSERT = 47; + public static readonly VIRTUAL = 48; + public static readonly VOID = 49; + public static readonly WEBSERVICE = 50; + public static readonly WHEN = 51; + public static readonly WHILE = 52; + public static readonly WITH = 53; + public static readonly WITHOUT = 54; + public static readonly LIST = 55; + public static readonly MAP = 56; + public static readonly SYSTEM = 57; + public static readonly USER = 58; + public static readonly SELECT = 59; + public static readonly COUNT = 60; + public static readonly FROM = 61; + public static readonly AS = 62; + public static readonly USING = 63; + public static readonly SCOPE = 64; + public static readonly WHERE = 65; + public static readonly ORDER = 66; + public static readonly BY = 67; + public static readonly LIMIT = 68; + public static readonly SOQLAND = 69; + public static readonly SOQLOR = 70; + public static readonly NOT = 71; + public static readonly AVG = 72; + public static readonly COUNT_DISTINCT = 73; + public static readonly MIN = 74; + public static readonly MAX = 75; + public static readonly SUM = 76; + public static readonly TYPEOF = 77; + public static readonly END = 78; + public static readonly THEN = 79; + public static readonly LIKE = 80; + public static readonly IN = 81; + public static readonly INCLUDES = 82; + public static readonly EXCLUDES = 83; + public static readonly ASC = 84; + public static readonly DESC = 85; + public static readonly NULLS = 86; + public static readonly FIRST = 87; + public static readonly LAST = 88; + public static readonly GROUP = 89; + public static readonly ALL = 90; + public static readonly ROWS = 91; + public static readonly VIEW = 92; + public static readonly HAVING = 93; + public static readonly ROLLUP = 94; + public static readonly TOLABEL = 95; + public static readonly OFFSET = 96; + public static readonly DATA = 97; + public static readonly CATEGORY = 98; + public static readonly AT = 99; + public static readonly ABOVE = 100; + public static readonly BELOW = 101; + public static readonly ABOVE_OR_BELOW = 102; + public static readonly SECURITY_ENFORCED = 103; + public static readonly SYSTEM_MODE = 104; + public static readonly USER_MODE = 105; + public static readonly REFERENCE = 106; + public static readonly CUBE = 107; + public static readonly FORMAT = 108; + public static readonly TRACKING = 109; + public static readonly VIEWSTAT = 110; + public static readonly CUSTOM = 111; + public static readonly STANDARD = 112; + public static readonly DISTANCE = 113; + public static readonly GEOLOCATION = 114; + public static readonly CALENDAR_MONTH = 115; + public static readonly CALENDAR_QUARTER = 116; + public static readonly CALENDAR_YEAR = 117; + public static readonly DAY_IN_MONTH = 118; + public static readonly DAY_IN_WEEK = 119; + public static readonly DAY_IN_YEAR = 120; + public static readonly DAY_ONLY = 121; + public static readonly FISCAL_MONTH = 122; + public static readonly FISCAL_QUARTER = 123; + public static readonly FISCAL_YEAR = 124; + public static readonly HOUR_IN_DAY = 125; + public static readonly WEEK_IN_MONTH = 126; + public static readonly WEEK_IN_YEAR = 127; + public static readonly CONVERT_TIMEZONE = 128; + public static readonly YESTERDAY = 129; + public static readonly TODAY = 130; + public static readonly TOMORROW = 131; + public static readonly LAST_WEEK = 132; + public static readonly THIS_WEEK = 133; + public static readonly NEXT_WEEK = 134; + public static readonly LAST_MONTH = 135; + public static readonly THIS_MONTH = 136; + public static readonly NEXT_MONTH = 137; + public static readonly LAST_90_DAYS = 138; + public static readonly NEXT_90_DAYS = 139; + public static readonly LAST_N_DAYS_N = 140; + public static readonly NEXT_N_DAYS_N = 141; + public static readonly N_DAYS_AGO_N = 142; + public static readonly NEXT_N_WEEKS_N = 143; + public static readonly LAST_N_WEEKS_N = 144; + public static readonly N_WEEKS_AGO_N = 145; + public static readonly NEXT_N_MONTHS_N = 146; + public static readonly LAST_N_MONTHS_N = 147; + public static readonly N_MONTHS_AGO_N = 148; + public static readonly THIS_QUARTER = 149; + public static readonly LAST_QUARTER = 150; + public static readonly NEXT_QUARTER = 151; + public static readonly NEXT_N_QUARTERS_N = 152; + public static readonly LAST_N_QUARTERS_N = 153; + public static readonly N_QUARTERS_AGO_N = 154; + public static readonly THIS_YEAR = 155; + public static readonly LAST_YEAR = 156; + public static readonly NEXT_YEAR = 157; + public static readonly NEXT_N_YEARS_N = 158; + public static readonly LAST_N_YEARS_N = 159; + public static readonly N_YEARS_AGO_N = 160; + public static readonly THIS_FISCAL_QUARTER = 161; + public static readonly LAST_FISCAL_QUARTER = 162; + public static readonly NEXT_FISCAL_QUARTER = 163; + public static readonly NEXT_N_FISCAL_QUARTERS_N = 164; + public static readonly LAST_N_FISCAL_QUARTERS_N = 165; + public static readonly N_FISCAL_QUARTERS_AGO_N = 166; + public static readonly THIS_FISCAL_YEAR = 167; + public static readonly LAST_FISCAL_YEAR = 168; + public static readonly NEXT_FISCAL_YEAR = 169; + public static readonly NEXT_N_FISCAL_YEARS_N = 170; + public static readonly LAST_N_FISCAL_YEARS_N = 171; + public static readonly N_FISCAL_YEARS_AGO_N = 172; + public static readonly DateLiteral = 173; + public static readonly DateTimeLiteral = 174; + public static readonly IntegralCurrencyLiteral = 175; + public static readonly FIND = 176; + public static readonly EMAIL = 177; + public static readonly NAME = 178; + public static readonly PHONE = 179; + public static readonly SIDEBAR = 180; + public static readonly FIELDS = 181; + public static readonly METADATA = 182; + public static readonly PRICEBOOKID = 183; + public static readonly NETWORK = 184; + public static readonly SNIPPET = 185; + public static readonly TARGET_LENGTH = 186; + public static readonly DIVISION = 187; + public static readonly RETURNING = 188; + public static readonly LISTVIEW = 189; + public static readonly FindLiteral = 190; + public static readonly FindLiteralAlt = 191; + public static readonly IntegerLiteral = 192; + public static readonly LongLiteral = 193; + public static readonly NumberLiteral = 194; + public static readonly BooleanLiteral = 195; + public static readonly StringLiteral = 196; + public static readonly NullLiteral = 197; + public static readonly LPAREN = 198; + public static readonly RPAREN = 199; + public static readonly LBRACE = 200; + public static readonly RBRACE = 201; + public static readonly LBRACK = 202; + public static readonly RBRACK = 203; + public static readonly SEMI = 204; + public static readonly COMMA = 205; + public static readonly DOT = 206; + public static readonly ASSIGN = 207; + public static readonly GT = 208; + public static readonly LT = 209; + public static readonly BANG = 210; + public static readonly TILDE = 211; + public static readonly QUESTIONDOT = 212; + public static readonly QUESTION = 213; + public static readonly DOUBLEQUESTION = 214; + public static readonly COLON = 215; + public static readonly EQUAL = 216; + public static readonly TRIPLEEQUAL = 217; + public static readonly NOTEQUAL = 218; + public static readonly LESSANDGREATER = 219; + public static readonly TRIPLENOTEQUAL = 220; + public static readonly AND = 221; + public static readonly OR = 222; + public static readonly INC = 223; + public static readonly DEC = 224; + public static readonly ADD = 225; + public static readonly SUB = 226; + public static readonly MUL = 227; + public static readonly DIV = 228; + public static readonly BITAND = 229; + public static readonly BITOR = 230; + public static readonly CARET = 231; + public static readonly MAPTO = 232; + public static readonly ADD_ASSIGN = 233; + public static readonly SUB_ASSIGN = 234; + public static readonly MUL_ASSIGN = 235; + public static readonly DIV_ASSIGN = 236; + public static readonly AND_ASSIGN = 237; + public static readonly OR_ASSIGN = 238; + public static readonly XOR_ASSIGN = 239; + public static readonly LSHIFT_ASSIGN = 240; + public static readonly RSHIFT_ASSIGN = 241; + public static readonly URSHIFT_ASSIGN = 242; + public static readonly ATSIGN = 243; + public static readonly Identifier = 244; + public static readonly WS = 245; + public static readonly DOC_COMMENT = 246; + public static readonly COMMENT = 247; + public static readonly LINE_COMMENT = 248; + public static readonly RULE_triggerUnit = 0; + public static readonly RULE_triggerCase = 1; + public static readonly RULE_compilationUnit = 2; + public static readonly RULE_typeDeclaration = 3; + public static readonly RULE_classDeclaration = 4; + public static readonly RULE_enumDeclaration = 5; + public static readonly RULE_enumConstants = 6; + public static readonly RULE_interfaceDeclaration = 7; + public static readonly RULE_typeList = 8; + public static readonly RULE_classBody = 9; + public static readonly RULE_interfaceBody = 10; + public static readonly RULE_classBodyDeclaration = 11; + public static readonly RULE_modifier = 12; + public static readonly RULE_memberDeclaration = 13; + public static readonly RULE_methodDeclaration = 14; + public static readonly RULE_constructorDeclaration = 15; + public static readonly RULE_fieldDeclaration = 16; + public static readonly RULE_propertyDeclaration = 17; + public static readonly RULE_interfaceMethodDeclaration = 18; + public static readonly RULE_variableDeclarators = 19; + public static readonly RULE_variableDeclarator = 20; + public static readonly RULE_arrayInitializer = 21; + public static readonly RULE_typeRef = 22; + public static readonly RULE_arraySubscripts = 23; + public static readonly RULE_typeName = 24; + public static readonly RULE_typeArguments = 25; + public static readonly RULE_formalParameters = 26; + public static readonly RULE_formalParameterList = 27; + public static readonly RULE_formalParameter = 28; + public static readonly RULE_qualifiedName = 29; + public static readonly RULE_literal = 30; + public static readonly RULE_annotation = 31; + public static readonly RULE_elementValuePairs = 32; + public static readonly RULE_elementValuePair = 33; + public static readonly RULE_elementValue = 34; + public static readonly RULE_elementValueArrayInitializer = 35; + public static readonly RULE_block = 36; + public static readonly RULE_localVariableDeclarationStatement = 37; + public static readonly RULE_localVariableDeclaration = 38; + public static readonly RULE_statement = 39; + public static readonly RULE_ifStatement = 40; + public static readonly RULE_switchStatement = 41; + public static readonly RULE_whenControl = 42; + public static readonly RULE_whenValue = 43; + public static readonly RULE_whenLiteral = 44; + public static readonly RULE_forStatement = 45; + public static readonly RULE_whileStatement = 46; + public static readonly RULE_doWhileStatement = 47; + public static readonly RULE_tryStatement = 48; + public static readonly RULE_returnStatement = 49; + public static readonly RULE_throwStatement = 50; + public static readonly RULE_breakStatement = 51; + public static readonly RULE_continueStatement = 52; + public static readonly RULE_accessLevel = 53; + public static readonly RULE_insertStatement = 54; + public static readonly RULE_updateStatement = 55; + public static readonly RULE_deleteStatement = 56; + public static readonly RULE_undeleteStatement = 57; + public static readonly RULE_upsertStatement = 58; + public static readonly RULE_mergeStatement = 59; + public static readonly RULE_runAsStatement = 60; + public static readonly RULE_expressionStatement = 61; + public static readonly RULE_propertyBlock = 62; + public static readonly RULE_getter = 63; + public static readonly RULE_setter = 64; + public static readonly RULE_catchClause = 65; + public static readonly RULE_finallyBlock = 66; + public static readonly RULE_forControl = 67; + public static readonly RULE_forInit = 68; + public static readonly RULE_enhancedForControl = 69; + public static readonly RULE_forUpdate = 70; + public static readonly RULE_parExpression = 71; + public static readonly RULE_expressionList = 72; + public static readonly RULE_expression = 73; + public static readonly RULE_primary = 74; + public static readonly RULE_methodCall = 75; + public static readonly RULE_dotMethodCall = 76; + public static readonly RULE_creator = 77; + public static readonly RULE_createdName = 78; + public static readonly RULE_idCreatedNamePair = 79; + public static readonly RULE_noRest = 80; + public static readonly RULE_classCreatorRest = 81; + public static readonly RULE_arrayCreatorRest = 82; + public static readonly RULE_mapCreatorRest = 83; + public static readonly RULE_mapCreatorRestPair = 84; + public static readonly RULE_setCreatorRest = 85; + public static readonly RULE_arguments = 86; + public static readonly RULE_soqlLiteral = 87; + public static readonly RULE_query = 88; + public static readonly RULE_subQuery = 89; + public static readonly RULE_selectList = 90; + public static readonly RULE_selectEntry = 91; + public static readonly RULE_fieldName = 92; + public static readonly RULE_fromNameList = 93; + public static readonly RULE_subFieldList = 94; + public static readonly RULE_subFieldEntry = 95; + public static readonly RULE_soqlFieldsParameter = 96; + public static readonly RULE_soqlFunction = 97; + public static readonly RULE_dateFieldName = 98; + public static readonly RULE_locationValue = 99; + public static readonly RULE_coordinateValue = 100; + public static readonly RULE_typeOf = 101; + public static readonly RULE_whenClause = 102; + public static readonly RULE_elseClause = 103; + public static readonly RULE_fieldNameList = 104; + public static readonly RULE_usingScope = 105; + public static readonly RULE_whereClause = 106; + public static readonly RULE_logicalExpression = 107; + public static readonly RULE_conditionalExpression = 108; + public static readonly RULE_fieldExpression = 109; + public static readonly RULE_comparisonOperator = 110; + public static readonly RULE_value = 111; + public static readonly RULE_valueList = 112; + public static readonly RULE_signedNumber = 113; + public static readonly RULE_withClause = 114; + public static readonly RULE_filteringExpression = 115; + public static readonly RULE_dataCategorySelection = 116; + public static readonly RULE_dataCategoryName = 117; + public static readonly RULE_filteringSelector = 118; + public static readonly RULE_groupByClause = 119; + public static readonly RULE_orderByClause = 120; + public static readonly RULE_fieldOrderList = 121; + public static readonly RULE_fieldOrder = 122; + public static readonly RULE_limitClause = 123; + public static readonly RULE_offsetClause = 124; + public static readonly RULE_allRowsClause = 125; + public static readonly RULE_forClauses = 126; + public static readonly RULE_boundExpression = 127; + public static readonly RULE_dateFormula = 128; + public static readonly RULE_signedInteger = 129; + public static readonly RULE_soqlId = 130; + public static readonly RULE_soslLiteral = 131; + public static readonly RULE_soslLiteralAlt = 132; + public static readonly RULE_soslClauses = 133; + public static readonly RULE_searchGroup = 134; + public static readonly RULE_fieldSpecList = 135; + public static readonly RULE_fieldSpec = 136; + public static readonly RULE_fieldList = 137; + public static readonly RULE_updateList = 138; + public static readonly RULE_updateType = 139; + public static readonly RULE_networkList = 140; + public static readonly RULE_soslId = 141; + public static readonly RULE_id = 142; + public static readonly RULE_anyId = 143; + + public static readonly literalNames = [ + null, "'abstract'", "'after'", "'before'", "'break'", "'catch'", + "'class'", "'continue'", "'delete'", "'do'", "'else'", "'enum'", + "'extends'", "'final'", "'finally'", "'for'", "'get'", "'global'", + "'if'", "'implements'", "'inherited'", "'insert'", "'instanceof'", + "'interface'", "'merge'", "'new'", "'null'", "'on'", "'override'", + "'private'", "'protected'", "'public'", "'return'", "'system.runas'", + "'set'", "'sharing'", "'static'", "'super'", "'switch'", "'testmethod'", + "'this'", "'throw'", "'transient'", "'trigger'", "'try'", "'undelete'", + "'update'", "'upsert'", "'virtual'", "'void'", "'webservice'", "'when'", + "'while'", "'with'", "'without'", "'list'", "'map'", "'system'", + "'user'", "'select'", "'count'", "'from'", "'as'", "'using'", "'scope'", + "'where'", "'order'", "'by'", "'limit'", "'and'", "'or'", "'not'", + "'avg'", "'count_distinct'", "'min'", "'max'", "'sum'", "'typeof'", + "'end'", "'then'", "'like'", "'in'", "'includes'", "'excludes'", + "'asc'", "'desc'", "'nulls'", "'first'", "'last'", "'group'", "'all'", + "'rows'", "'view'", "'having'", "'rollup'", "'tolabel'", "'offset'", + "'data'", "'category'", "'at'", "'above'", "'below'", "'above_or_below'", + "'security_enforced'", "'system_mode'", "'user_mode'", "'reference'", + "'cube'", "'format'", "'tracking'", "'viewstat'", "'custom'", "'standard'", + "'distance'", "'geolocation'", "'calendar_month'", "'calendar_quarter'", + "'calendar_year'", "'day_in_month'", "'day_in_week'", "'day_in_year'", + "'day_only'", "'fiscal_month'", "'fiscal_quarter'", "'fiscal_year'", + "'hour_in_day'", "'week_in_month'", "'week_in_year'", "'converttimezone'", + "'yesterday'", "'today'", "'tomorrow'", "'last_week'", "'this_week'", + "'next_week'", "'last_month'", "'this_month'", "'next_month'", "'last_90_days'", + "'next_90_days'", "'last_n_days'", "'next_n_days'", "'n_days_ago'", + "'next_n_weeks'", "'last_n_weeks'", "'n_weeks_ago'", "'next_n_months'", + "'last_n_months'", "'n_months_ago'", "'this_quarter'", "'last_quarter'", + "'next_quarter'", "'next_n_quarters'", "'last_n_quarters'", "'n_quarters_ago'", + "'this_year'", "'last_year'", "'next_year'", "'next_n_years'", "'last_n_years'", + "'n_years_ago'", "'this_fiscal_quarter'", "'last_fiscal_quarter'", + "'next_fiscal_quarter'", "'next_n_fiscal_quarters'", "'last_n_fiscal_quarters'", + "'n_fiscal_quarters_ago'", "'this_fiscal_year'", "'last_fiscal_year'", + "'next_fiscal_year'", "'next_n_fiscal_years'", "'last_n_fiscal_years'", + "'n_fiscal_years_ago'", null, null, null, "'find'", "'email'", "'name'", + "'phone'", "'sidebar'", "'fields'", "'metadata'", "'pricebookid'", + "'network'", "'snippet'", "'target_length'", "'division'", "'returning'", + "'listview'", null, null, null, null, null, null, null, null, "'('", + "')'", "'{'", "'}'", "'['", "']'", "';'", "','", "'.'", "'='", "'>'", + "'<'", "'!'", "'~'", "'?.'", "'?'", "'??'", "':'", "'=='", "'==='", + "'!='", "'<>'", "'!=='", "'&&'", "'||'", "'++'", "'--'", "'+'", + "'-'", "'*'", "'/'", "'&'", "'|'", "'^'", "'=>'", "'+='", "'-='", + "'*='", "'/='", "'&='", "'|='", "'^='", "'<<='", "'>>='", "'>>>='", + "'@'" + ]; + + public static readonly symbolicNames = [ + null, "ABSTRACT", "AFTER", "BEFORE", "BREAK", "CATCH", "CLASS", + "CONTINUE", "DELETE", "DO", "ELSE", "ENUM", "EXTENDS", "FINAL", + "FINALLY", "FOR", "GET", "GLOBAL", "IF", "IMPLEMENTS", "INHERITED", + "INSERT", "INSTANCEOF", "INTERFACE", "MERGE", "NEW", "NULL", "ON", + "OVERRIDE", "PRIVATE", "PROTECTED", "PUBLIC", "RETURN", "SYSTEMRUNAS", + "SET", "SHARING", "STATIC", "SUPER", "SWITCH", "TESTMETHOD", "THIS", + "THROW", "TRANSIENT", "TRIGGER", "TRY", "UNDELETE", "UPDATE", "UPSERT", + "VIRTUAL", "VOID", "WEBSERVICE", "WHEN", "WHILE", "WITH", "WITHOUT", + "LIST", "MAP", "SYSTEM", "USER", "SELECT", "COUNT", "FROM", "AS", + "USING", "SCOPE", "WHERE", "ORDER", "BY", "LIMIT", "SOQLAND", "SOQLOR", + "NOT", "AVG", "COUNT_DISTINCT", "MIN", "MAX", "SUM", "TYPEOF", "END", + "THEN", "LIKE", "IN", "INCLUDES", "EXCLUDES", "ASC", "DESC", "NULLS", + "FIRST", "LAST", "GROUP", "ALL", "ROWS", "VIEW", "HAVING", "ROLLUP", + "TOLABEL", "OFFSET", "DATA", "CATEGORY", "AT", "ABOVE", "BELOW", + "ABOVE_OR_BELOW", "SECURITY_ENFORCED", "SYSTEM_MODE", "USER_MODE", + "REFERENCE", "CUBE", "FORMAT", "TRACKING", "VIEWSTAT", "CUSTOM", + "STANDARD", "DISTANCE", "GEOLOCATION", "CALENDAR_MONTH", "CALENDAR_QUARTER", + "CALENDAR_YEAR", "DAY_IN_MONTH", "DAY_IN_WEEK", "DAY_IN_YEAR", "DAY_ONLY", + "FISCAL_MONTH", "FISCAL_QUARTER", "FISCAL_YEAR", "HOUR_IN_DAY", + "WEEK_IN_MONTH", "WEEK_IN_YEAR", "CONVERT_TIMEZONE", "YESTERDAY", + "TODAY", "TOMORROW", "LAST_WEEK", "THIS_WEEK", "NEXT_WEEK", "LAST_MONTH", + "THIS_MONTH", "NEXT_MONTH", "LAST_90_DAYS", "NEXT_90_DAYS", "LAST_N_DAYS_N", + "NEXT_N_DAYS_N", "N_DAYS_AGO_N", "NEXT_N_WEEKS_N", "LAST_N_WEEKS_N", + "N_WEEKS_AGO_N", "NEXT_N_MONTHS_N", "LAST_N_MONTHS_N", "N_MONTHS_AGO_N", + "THIS_QUARTER", "LAST_QUARTER", "NEXT_QUARTER", "NEXT_N_QUARTERS_N", + "LAST_N_QUARTERS_N", "N_QUARTERS_AGO_N", "THIS_YEAR", "LAST_YEAR", + "NEXT_YEAR", "NEXT_N_YEARS_N", "LAST_N_YEARS_N", "N_YEARS_AGO_N", + "THIS_FISCAL_QUARTER", "LAST_FISCAL_QUARTER", "NEXT_FISCAL_QUARTER", + "NEXT_N_FISCAL_QUARTERS_N", "LAST_N_FISCAL_QUARTERS_N", "N_FISCAL_QUARTERS_AGO_N", + "THIS_FISCAL_YEAR", "LAST_FISCAL_YEAR", "NEXT_FISCAL_YEAR", "NEXT_N_FISCAL_YEARS_N", + "LAST_N_FISCAL_YEARS_N", "N_FISCAL_YEARS_AGO_N", "DateLiteral", + "DateTimeLiteral", "IntegralCurrencyLiteral", "FIND", "EMAIL", "NAME", + "PHONE", "SIDEBAR", "FIELDS", "METADATA", "PRICEBOOKID", "NETWORK", + "SNIPPET", "TARGET_LENGTH", "DIVISION", "RETURNING", "LISTVIEW", + "FindLiteral", "FindLiteralAlt", "IntegerLiteral", "LongLiteral", + "NumberLiteral", "BooleanLiteral", "StringLiteral", "NullLiteral", + "LPAREN", "RPAREN", "LBRACE", "RBRACE", "LBRACK", "RBRACK", "SEMI", + "COMMA", "DOT", "ASSIGN", "GT", "LT", "BANG", "TILDE", "QUESTIONDOT", + "QUESTION", "DOUBLEQUESTION", "COLON", "EQUAL", "TRIPLEEQUAL", "NOTEQUAL", + "LESSANDGREATER", "TRIPLENOTEQUAL", "AND", "OR", "INC", "DEC", "ADD", + "SUB", "MUL", "DIV", "BITAND", "BITOR", "CARET", "MAPTO", "ADD_ASSIGN", + "SUB_ASSIGN", "MUL_ASSIGN", "DIV_ASSIGN", "AND_ASSIGN", "OR_ASSIGN", + "XOR_ASSIGN", "LSHIFT_ASSIGN", "RSHIFT_ASSIGN", "URSHIFT_ASSIGN", + "ATSIGN", "Identifier", "WS", "DOC_COMMENT", "COMMENT", "LINE_COMMENT" + ]; + public static readonly ruleNames = [ + "triggerUnit", "triggerCase", "compilationUnit", "typeDeclaration", + "classDeclaration", "enumDeclaration", "enumConstants", "interfaceDeclaration", + "typeList", "classBody", "interfaceBody", "classBodyDeclaration", + "modifier", "memberDeclaration", "methodDeclaration", "constructorDeclaration", + "fieldDeclaration", "propertyDeclaration", "interfaceMethodDeclaration", + "variableDeclarators", "variableDeclarator", "arrayInitializer", + "typeRef", "arraySubscripts", "typeName", "typeArguments", "formalParameters", + "formalParameterList", "formalParameter", "qualifiedName", "literal", + "annotation", "elementValuePairs", "elementValuePair", "elementValue", + "elementValueArrayInitializer", "block", "localVariableDeclarationStatement", + "localVariableDeclaration", "statement", "ifStatement", "switchStatement", + "whenControl", "whenValue", "whenLiteral", "forStatement", "whileStatement", + "doWhileStatement", "tryStatement", "returnStatement", "throwStatement", + "breakStatement", "continueStatement", "accessLevel", "insertStatement", + "updateStatement", "deleteStatement", "undeleteStatement", "upsertStatement", + "mergeStatement", "runAsStatement", "expressionStatement", "propertyBlock", + "getter", "setter", "catchClause", "finallyBlock", "forControl", + "forInit", "enhancedForControl", "forUpdate", "parExpression", "expressionList", + "expression", "primary", "methodCall", "dotMethodCall", "creator", + "createdName", "idCreatedNamePair", "noRest", "classCreatorRest", + "arrayCreatorRest", "mapCreatorRest", "mapCreatorRestPair", "setCreatorRest", + "arguments", "soqlLiteral", "query", "subQuery", "selectList", "selectEntry", + "fieldName", "fromNameList", "subFieldList", "subFieldEntry", "soqlFieldsParameter", + "soqlFunction", "dateFieldName", "locationValue", "coordinateValue", + "typeOf", "whenClause", "elseClause", "fieldNameList", "usingScope", + "whereClause", "logicalExpression", "conditionalExpression", "fieldExpression", + "comparisonOperator", "value", "valueList", "signedNumber", "withClause", + "filteringExpression", "dataCategorySelection", "dataCategoryName", + "filteringSelector", "groupByClause", "orderByClause", "fieldOrderList", + "fieldOrder", "limitClause", "offsetClause", "allRowsClause", "forClauses", + "boundExpression", "dateFormula", "signedInteger", "soqlId", "soslLiteral", + "soslLiteralAlt", "soslClauses", "searchGroup", "fieldSpecList", + "fieldSpec", "fieldList", "updateList", "updateType", "networkList", + "soslId", "id", "anyId", + ]; + + public get grammarFileName(): string { return "ApexParser.g4"; } + public get literalNames(): (string | null)[] { return ApexParser.literalNames; } + public get symbolicNames(): (string | null)[] { return ApexParser.symbolicNames; } + public get ruleNames(): string[] { return ApexParser.ruleNames; } + public get serializedATN(): number[] { return ApexParser._serializedATN; } + + protected createFailedPredicateException(predicate?: string, message?: string): antlr.FailedPredicateException { + return new antlr.FailedPredicateException(this, predicate, message); + } + + public constructor(input: antlr.TokenStream) { + super(input); + this.interpreter = new antlr.ParserATNSimulator(this, ApexParser._ATN, ApexParser.decisionsToDFA, new antlr.PredictionContextCache()); + } + public triggerUnit(): TriggerUnitContext { + const localContext = new TriggerUnitContext(this.context, this.state); + this.enterRule(localContext, 0, ApexParser.RULE_triggerUnit); + let _la: number; + try { + this.enterOuterAlt(localContext, 1); + { + this.state = 288; + this.match(ApexParser.TRIGGER); + this.state = 289; + this.id(); + this.state = 290; + this.match(ApexParser.ON); + this.state = 291; + localContext._object = this.id(); + this.state = 292; + this.match(ApexParser.LPAREN); + this.state = 293; + this.triggerCase(); + this.state = 298; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + while (_la === 205) { + { + { + this.state = 294; + this.match(ApexParser.COMMA); + this.state = 295; + this.triggerCase(); + } + } + this.state = 300; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + } + this.state = 301; + this.match(ApexParser.RPAREN); + this.state = 302; + this.block(); + this.state = 303; + this.match(ApexParser.EOF); + } + } + catch (re) { + if (re instanceof antlr.RecognitionException) { + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return localContext; + } + public triggerCase(): TriggerCaseContext { + const localContext = new TriggerCaseContext(this.context, this.state); + this.enterRule(localContext, 2, ApexParser.RULE_triggerCase); + let _la: number; + try { + this.enterOuterAlt(localContext, 1); + { + this.state = 305; + localContext._when = this.tokenStream.LT(1); + _la = this.tokenStream.LA(1); + if(!(_la === 2 || _la === 3)) { + localContext._when = this.errorHandler.recoverInline(this); + } + else { + this.errorHandler.reportMatch(this); + this.consume(); + } + this.state = 306; + localContext._operation = this.tokenStream.LT(1); + _la = this.tokenStream.LA(1); + if(!(_la === 8 || _la === 21 || _la === 45 || _la === 46)) { + localContext._operation = this.errorHandler.recoverInline(this); + } + else { + this.errorHandler.reportMatch(this); + this.consume(); + } + } + } + catch (re) { + if (re instanceof antlr.RecognitionException) { + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return localContext; + } + public compilationUnit(): CompilationUnitContext { + const localContext = new CompilationUnitContext(this.context, this.state); + this.enterRule(localContext, 4, ApexParser.RULE_compilationUnit); + let _la: number; + try { + this.enterOuterAlt(localContext, 1); + { + this.state = 311; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + while ((((_la) & ~0x1F) === 0 && ((1 << _la) & 4036110402) !== 0) || ((((_la - 36)) & ~0x1F) === 0 && ((1 << (_la - 36)) & 413769) !== 0) || _la === 243) { + { + { + this.state = 308; + this.typeDeclaration(); + } + } + this.state = 313; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + } + this.state = 314; + this.match(ApexParser.EOF); + } + } + catch (re) { + if (re instanceof antlr.RecognitionException) { + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return localContext; + } + public typeDeclaration(): TypeDeclarationContext { + const localContext = new TypeDeclarationContext(this.context, this.state); + this.enterRule(localContext, 6, ApexParser.RULE_typeDeclaration); + let _la: number; + try { + this.state = 337; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 5, this.context) ) { + case 1: + this.enterOuterAlt(localContext, 1); + { + this.state = 319; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + while ((((_la) & ~0x1F) === 0 && ((1 << _la) & 4027719682) !== 0) || ((((_la - 36)) & ~0x1F) === 0 && ((1 << (_la - 36)) & 413769) !== 0) || _la === 243) { + { + { + this.state = 316; + this.modifier(); + } + } + this.state = 321; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + } + this.state = 322; + this.classDeclaration(); + } + break; + case 2: + this.enterOuterAlt(localContext, 2); + { + this.state = 326; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + while ((((_la) & ~0x1F) === 0 && ((1 << _la) & 4027719682) !== 0) || ((((_la - 36)) & ~0x1F) === 0 && ((1 << (_la - 36)) & 413769) !== 0) || _la === 243) { + { + { + this.state = 323; + this.modifier(); + } + } + this.state = 328; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + } + this.state = 329; + this.enumDeclaration(); + } + break; + case 3: + this.enterOuterAlt(localContext, 3); + { + this.state = 333; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + while ((((_la) & ~0x1F) === 0 && ((1 << _la) & 4027719682) !== 0) || ((((_la - 36)) & ~0x1F) === 0 && ((1 << (_la - 36)) & 413769) !== 0) || _la === 243) { + { + { + this.state = 330; + this.modifier(); + } + } + this.state = 335; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + } + this.state = 336; + this.interfaceDeclaration(); + } + break; + } + } + catch (re) { + if (re instanceof antlr.RecognitionException) { + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return localContext; + } + public classDeclaration(): ClassDeclarationContext { + const localContext = new ClassDeclarationContext(this.context, this.state); + this.enterRule(localContext, 8, ApexParser.RULE_classDeclaration); + let _la: number; + try { + this.enterOuterAlt(localContext, 1); + { + this.state = 339; + this.match(ApexParser.CLASS); + this.state = 340; + this.id(); + this.state = 343; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 12) { + { + this.state = 341; + this.match(ApexParser.EXTENDS); + this.state = 342; + this.typeRef(); + } + } + + this.state = 347; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 19) { + { + this.state = 345; + this.match(ApexParser.IMPLEMENTS); + this.state = 346; + this.typeList(); + } + } + + this.state = 349; + this.classBody(); + } + } + catch (re) { + if (re instanceof antlr.RecognitionException) { + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return localContext; + } + public enumDeclaration(): EnumDeclarationContext { + const localContext = new EnumDeclarationContext(this.context, this.state); + this.enterRule(localContext, 10, ApexParser.RULE_enumDeclaration); + let _la: number; + try { + this.enterOuterAlt(localContext, 1); + { + this.state = 351; + this.match(ApexParser.ENUM); + this.state = 352; + this.id(); + this.state = 353; + this.match(ApexParser.LBRACE); + this.state = 355; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if ((((_la) & ~0x1F) === 0 && ((1 << _la) & 5308428) !== 0) || ((((_la - 34)) & ~0x1F) === 0 && ((1 << (_la - 34)) & 4288283411) !== 0) || ((((_la - 66)) & ~0x1F) === 0 && ((1 << (_la - 66)) & 4294967295) !== 0) || ((((_la - 98)) & ~0x1F) === 0 && ((1 << (_la - 98)) & 4294967295) !== 0) || ((((_la - 130)) & ~0x1F) === 0 && ((1 << (_la - 130)) & 4294967295) !== 0) || ((((_la - 162)) & ~0x1F) === 0 && ((1 << (_la - 162)) & 268429311) !== 0) || _la === 244) { + { + this.state = 354; + this.enumConstants(); + } + } + + this.state = 357; + this.match(ApexParser.RBRACE); + } + } + catch (re) { + if (re instanceof antlr.RecognitionException) { + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return localContext; + } + public enumConstants(): EnumConstantsContext { + const localContext = new EnumConstantsContext(this.context, this.state); + this.enterRule(localContext, 12, ApexParser.RULE_enumConstants); + let _la: number; + try { + this.enterOuterAlt(localContext, 1); + { + this.state = 359; + this.id(); + this.state = 364; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + while (_la === 205) { + { + { + this.state = 360; + this.match(ApexParser.COMMA); + this.state = 361; + this.id(); + } + } + this.state = 366; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + } + } + } + catch (re) { + if (re instanceof antlr.RecognitionException) { + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return localContext; + } + public interfaceDeclaration(): InterfaceDeclarationContext { + const localContext = new InterfaceDeclarationContext(this.context, this.state); + this.enterRule(localContext, 14, ApexParser.RULE_interfaceDeclaration); + let _la: number; + try { + this.enterOuterAlt(localContext, 1); + { + this.state = 367; + this.match(ApexParser.INTERFACE); + this.state = 368; + this.id(); + this.state = 371; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 12) { + { + this.state = 369; + this.match(ApexParser.EXTENDS); + this.state = 370; + this.typeList(); + } + } + + this.state = 373; + this.interfaceBody(); + } + } + catch (re) { + if (re instanceof antlr.RecognitionException) { + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return localContext; + } + public typeList(): TypeListContext { + const localContext = new TypeListContext(this.context, this.state); + this.enterRule(localContext, 16, ApexParser.RULE_typeList); + let _la: number; + try { + this.enterOuterAlt(localContext, 1); + { + this.state = 375; + this.typeRef(); + this.state = 380; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + while (_la === 205) { + { + { + this.state = 376; + this.match(ApexParser.COMMA); + this.state = 377; + this.typeRef(); + } + } + this.state = 382; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + } + } + } + catch (re) { + if (re instanceof antlr.RecognitionException) { + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return localContext; + } + public classBody(): ClassBodyContext { + const localContext = new ClassBodyContext(this.context, this.state); + this.enterRule(localContext, 18, ApexParser.RULE_classBody); + let _la: number; + try { + this.enterOuterAlt(localContext, 1); + { + this.state = 383; + this.match(ApexParser.LBRACE); + this.state = 387; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + while ((((_la) & ~0x1F) === 0 && ((1 << _la) & 4040370254) !== 0) || ((((_la - 34)) & ~0x1F) === 0 && ((1 << (_la - 34)) & 4294689591) !== 0) || ((((_la - 66)) & ~0x1F) === 0 && ((1 << (_la - 66)) & 4294967295) !== 0) || ((((_la - 98)) & ~0x1F) === 0 && ((1 << (_la - 98)) & 4294967295) !== 0) || ((((_la - 130)) & ~0x1F) === 0 && ((1 << (_la - 130)) & 4294967295) !== 0) || ((((_la - 162)) & ~0x1F) === 0 && ((1 << (_la - 162)) & 268429311) !== 0) || _la === 200 || _la === 204 || _la === 243 || _la === 244) { + { + { + this.state = 384; + this.classBodyDeclaration(); + } + } + this.state = 389; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + } + this.state = 390; + this.match(ApexParser.RBRACE); + } + } + catch (re) { + if (re instanceof antlr.RecognitionException) { + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return localContext; + } + public interfaceBody(): InterfaceBodyContext { + const localContext = new InterfaceBodyContext(this.context, this.state); + this.enterRule(localContext, 20, ApexParser.RULE_interfaceBody); + let _la: number; + try { + this.enterOuterAlt(localContext, 1); + { + this.state = 392; + this.match(ApexParser.LBRACE); + this.state = 396; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + while ((((_la) & ~0x1F) === 0 && ((1 << _la) & 4031979534) !== 0) || ((((_la - 34)) & ~0x1F) === 0 && ((1 << (_la - 34)) & 4294689591) !== 0) || ((((_la - 66)) & ~0x1F) === 0 && ((1 << (_la - 66)) & 4294967295) !== 0) || ((((_la - 98)) & ~0x1F) === 0 && ((1 << (_la - 98)) & 4294967295) !== 0) || ((((_la - 130)) & ~0x1F) === 0 && ((1 << (_la - 130)) & 4294967295) !== 0) || ((((_la - 162)) & ~0x1F) === 0 && ((1 << (_la - 162)) & 268429311) !== 0) || _la === 243 || _la === 244) { + { + { + this.state = 393; + this.interfaceMethodDeclaration(); + } + } + this.state = 398; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + } + this.state = 399; + this.match(ApexParser.RBRACE); + } + } + catch (re) { + if (re instanceof antlr.RecognitionException) { + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return localContext; + } + public classBodyDeclaration(): ClassBodyDeclarationContext { + const localContext = new ClassBodyDeclarationContext(this.context, this.state); + this.enterRule(localContext, 22, ApexParser.RULE_classBodyDeclaration); + let _la: number; + try { + let alternative: number; + this.state = 413; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 16, this.context) ) { + case 1: + this.enterOuterAlt(localContext, 1); + { + this.state = 401; + this.match(ApexParser.SEMI); + } + break; + case 2: + this.enterOuterAlt(localContext, 2); + { + this.state = 403; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 36) { + { + this.state = 402; + this.match(ApexParser.STATIC); + } + } + + this.state = 405; + this.block(); + } + break; + case 3: + this.enterOuterAlt(localContext, 3); + { + this.state = 409; + this.errorHandler.sync(this); + alternative = this.interpreter.adaptivePredict(this.tokenStream, 15, this.context); + while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) { + if (alternative === 1) { + { + { + this.state = 406; + this.modifier(); + } + } + } + this.state = 411; + this.errorHandler.sync(this); + alternative = this.interpreter.adaptivePredict(this.tokenStream, 15, this.context); + } + this.state = 412; + this.memberDeclaration(); + } + break; + } + } + catch (re) { + if (re instanceof antlr.RecognitionException) { + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return localContext; + } + public modifier(): ModifierContext { + const localContext = new ModifierContext(this.context, this.state); + this.enterRule(localContext, 24, ApexParser.RULE_modifier); + try { + this.state = 434; + this.errorHandler.sync(this); + switch (this.tokenStream.LA(1)) { + case ApexParser.ATSIGN: + this.enterOuterAlt(localContext, 1); + { + this.state = 415; + this.annotation(); + } + break; + case ApexParser.GLOBAL: + this.enterOuterAlt(localContext, 2); + { + this.state = 416; + this.match(ApexParser.GLOBAL); + } + break; + case ApexParser.PUBLIC: + this.enterOuterAlt(localContext, 3); + { + this.state = 417; + this.match(ApexParser.PUBLIC); + } + break; + case ApexParser.PROTECTED: + this.enterOuterAlt(localContext, 4); + { + this.state = 418; + this.match(ApexParser.PROTECTED); + } + break; + case ApexParser.PRIVATE: + this.enterOuterAlt(localContext, 5); + { + this.state = 419; + this.match(ApexParser.PRIVATE); + } + break; + case ApexParser.TRANSIENT: + this.enterOuterAlt(localContext, 6); + { + this.state = 420; + this.match(ApexParser.TRANSIENT); + } + break; + case ApexParser.STATIC: + this.enterOuterAlt(localContext, 7); + { + this.state = 421; + this.match(ApexParser.STATIC); + } + break; + case ApexParser.ABSTRACT: + this.enterOuterAlt(localContext, 8); + { + this.state = 422; + this.match(ApexParser.ABSTRACT); + } + break; + case ApexParser.FINAL: + this.enterOuterAlt(localContext, 9); + { + this.state = 423; + this.match(ApexParser.FINAL); + } + break; + case ApexParser.WEBSERVICE: + this.enterOuterAlt(localContext, 10); + { + this.state = 424; + this.match(ApexParser.WEBSERVICE); + } + break; + case ApexParser.OVERRIDE: + this.enterOuterAlt(localContext, 11); + { + this.state = 425; + this.match(ApexParser.OVERRIDE); + } + break; + case ApexParser.VIRTUAL: + this.enterOuterAlt(localContext, 12); + { + this.state = 426; + this.match(ApexParser.VIRTUAL); + } + break; + case ApexParser.TESTMETHOD: + this.enterOuterAlt(localContext, 13); + { + this.state = 427; + this.match(ApexParser.TESTMETHOD); + } + break; + case ApexParser.WITH: + this.enterOuterAlt(localContext, 14); + { + this.state = 428; + this.match(ApexParser.WITH); + this.state = 429; + this.match(ApexParser.SHARING); + } + break; + case ApexParser.WITHOUT: + this.enterOuterAlt(localContext, 15); + { + this.state = 430; + this.match(ApexParser.WITHOUT); + this.state = 431; + this.match(ApexParser.SHARING); + } + break; + case ApexParser.INHERITED: + this.enterOuterAlt(localContext, 16); + { + this.state = 432; + this.match(ApexParser.INHERITED); + this.state = 433; + this.match(ApexParser.SHARING); + } + break; + default: + throw new antlr.NoViableAltException(this); + } + } + catch (re) { + if (re instanceof antlr.RecognitionException) { + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return localContext; + } + public memberDeclaration(): MemberDeclarationContext { + const localContext = new MemberDeclarationContext(this.context, this.state); + this.enterRule(localContext, 26, ApexParser.RULE_memberDeclaration); + try { + this.state = 443; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 18, this.context) ) { + case 1: + this.enterOuterAlt(localContext, 1); + { + this.state = 436; + this.methodDeclaration(); + } + break; + case 2: + this.enterOuterAlt(localContext, 2); + { + this.state = 437; + this.fieldDeclaration(); + } + break; + case 3: + this.enterOuterAlt(localContext, 3); + { + this.state = 438; + this.constructorDeclaration(); + } + break; + case 4: + this.enterOuterAlt(localContext, 4); + { + this.state = 439; + this.interfaceDeclaration(); + } + break; + case 5: + this.enterOuterAlt(localContext, 5); + { + this.state = 440; + this.classDeclaration(); + } + break; + case 6: + this.enterOuterAlt(localContext, 6); + { + this.state = 441; + this.enumDeclaration(); + } + break; + case 7: + this.enterOuterAlt(localContext, 7); + { + this.state = 442; + this.propertyDeclaration(); + } + break; + } + } + catch (re) { + if (re instanceof antlr.RecognitionException) { + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return localContext; + } + public methodDeclaration(): MethodDeclarationContext { + const localContext = new MethodDeclarationContext(this.context, this.state); + this.enterRule(localContext, 28, ApexParser.RULE_methodDeclaration); + try { + this.enterOuterAlt(localContext, 1); + { + this.state = 447; + this.errorHandler.sync(this); + switch (this.tokenStream.LA(1)) { + case ApexParser.AFTER: + case ApexParser.BEFORE: + case ApexParser.GET: + case ApexParser.INHERITED: + case ApexParser.INSTANCEOF: + case ApexParser.SET: + case ApexParser.SHARING: + case ApexParser.SWITCH: + case ApexParser.TRANSIENT: + case ApexParser.TRIGGER: + case ApexParser.WHEN: + case ApexParser.WITH: + case ApexParser.WITHOUT: + case ApexParser.LIST: + case ApexParser.MAP: + case ApexParser.SYSTEM: + case ApexParser.USER: + case ApexParser.SELECT: + case ApexParser.COUNT: + case ApexParser.FROM: + case ApexParser.AS: + case ApexParser.USING: + case ApexParser.SCOPE: + case ApexParser.WHERE: + case ApexParser.ORDER: + case ApexParser.BY: + case ApexParser.LIMIT: + case ApexParser.SOQLAND: + case ApexParser.SOQLOR: + case ApexParser.NOT: + case ApexParser.AVG: + case ApexParser.COUNT_DISTINCT: + case ApexParser.MIN: + case ApexParser.MAX: + case ApexParser.SUM: + case ApexParser.TYPEOF: + case ApexParser.END: + case ApexParser.THEN: + case ApexParser.LIKE: + case ApexParser.IN: + case ApexParser.INCLUDES: + case ApexParser.EXCLUDES: + case ApexParser.ASC: + case ApexParser.DESC: + case ApexParser.NULLS: + case ApexParser.FIRST: + case ApexParser.LAST: + case ApexParser.GROUP: + case ApexParser.ALL: + case ApexParser.ROWS: + case ApexParser.VIEW: + case ApexParser.HAVING: + case ApexParser.ROLLUP: + case ApexParser.TOLABEL: + case ApexParser.OFFSET: + case ApexParser.DATA: + case ApexParser.CATEGORY: + case ApexParser.AT: + case ApexParser.ABOVE: + case ApexParser.BELOW: + case ApexParser.ABOVE_OR_BELOW: + case ApexParser.SECURITY_ENFORCED: + case ApexParser.SYSTEM_MODE: + case ApexParser.USER_MODE: + case ApexParser.REFERENCE: + case ApexParser.CUBE: + case ApexParser.FORMAT: + case ApexParser.TRACKING: + case ApexParser.VIEWSTAT: + case ApexParser.CUSTOM: + case ApexParser.STANDARD: + case ApexParser.DISTANCE: + case ApexParser.GEOLOCATION: + case ApexParser.CALENDAR_MONTH: + case ApexParser.CALENDAR_QUARTER: + case ApexParser.CALENDAR_YEAR: + case ApexParser.DAY_IN_MONTH: + case ApexParser.DAY_IN_WEEK: + case ApexParser.DAY_IN_YEAR: + case ApexParser.DAY_ONLY: + case ApexParser.FISCAL_MONTH: + case ApexParser.FISCAL_QUARTER: + case ApexParser.FISCAL_YEAR: + case ApexParser.HOUR_IN_DAY: + case ApexParser.WEEK_IN_MONTH: + case ApexParser.WEEK_IN_YEAR: + case ApexParser.CONVERT_TIMEZONE: + case ApexParser.YESTERDAY: + case ApexParser.TODAY: + case ApexParser.TOMORROW: + case ApexParser.LAST_WEEK: + case ApexParser.THIS_WEEK: + case ApexParser.NEXT_WEEK: + case ApexParser.LAST_MONTH: + case ApexParser.THIS_MONTH: + case ApexParser.NEXT_MONTH: + case ApexParser.LAST_90_DAYS: + case ApexParser.NEXT_90_DAYS: + case ApexParser.LAST_N_DAYS_N: + case ApexParser.NEXT_N_DAYS_N: + case ApexParser.N_DAYS_AGO_N: + case ApexParser.NEXT_N_WEEKS_N: + case ApexParser.LAST_N_WEEKS_N: + case ApexParser.N_WEEKS_AGO_N: + case ApexParser.NEXT_N_MONTHS_N: + case ApexParser.LAST_N_MONTHS_N: + case ApexParser.N_MONTHS_AGO_N: + case ApexParser.THIS_QUARTER: + case ApexParser.LAST_QUARTER: + case ApexParser.NEXT_QUARTER: + case ApexParser.NEXT_N_QUARTERS_N: + case ApexParser.LAST_N_QUARTERS_N: + case ApexParser.N_QUARTERS_AGO_N: + case ApexParser.THIS_YEAR: + case ApexParser.LAST_YEAR: + case ApexParser.NEXT_YEAR: + case ApexParser.NEXT_N_YEARS_N: + case ApexParser.LAST_N_YEARS_N: + case ApexParser.N_YEARS_AGO_N: + case ApexParser.THIS_FISCAL_QUARTER: + case ApexParser.LAST_FISCAL_QUARTER: + case ApexParser.NEXT_FISCAL_QUARTER: + case ApexParser.NEXT_N_FISCAL_QUARTERS_N: + case ApexParser.LAST_N_FISCAL_QUARTERS_N: + case ApexParser.N_FISCAL_QUARTERS_AGO_N: + case ApexParser.THIS_FISCAL_YEAR: + case ApexParser.LAST_FISCAL_YEAR: + case ApexParser.NEXT_FISCAL_YEAR: + case ApexParser.NEXT_N_FISCAL_YEARS_N: + case ApexParser.LAST_N_FISCAL_YEARS_N: + case ApexParser.N_FISCAL_YEARS_AGO_N: + case ApexParser.IntegralCurrencyLiteral: + case ApexParser.FIND: + case ApexParser.EMAIL: + case ApexParser.NAME: + case ApexParser.PHONE: + case ApexParser.SIDEBAR: + case ApexParser.FIELDS: + case ApexParser.METADATA: + case ApexParser.PRICEBOOKID: + case ApexParser.NETWORK: + case ApexParser.SNIPPET: + case ApexParser.TARGET_LENGTH: + case ApexParser.DIVISION: + case ApexParser.RETURNING: + case ApexParser.LISTVIEW: + case ApexParser.Identifier: + { + this.state = 445; + this.typeRef(); + } + break; + case ApexParser.VOID: + { + this.state = 446; + this.match(ApexParser.VOID); + } + break; + default: + throw new antlr.NoViableAltException(this); + } + this.state = 449; + this.id(); + this.state = 450; + this.formalParameters(); + this.state = 453; + this.errorHandler.sync(this); + switch (this.tokenStream.LA(1)) { + case ApexParser.LBRACE: + { + this.state = 451; + this.block(); + } + break; + case ApexParser.SEMI: + { + this.state = 452; + this.match(ApexParser.SEMI); + } + break; + default: + throw new antlr.NoViableAltException(this); + } + } + } + catch (re) { + if (re instanceof antlr.RecognitionException) { + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return localContext; + } + public constructorDeclaration(): ConstructorDeclarationContext { + const localContext = new ConstructorDeclarationContext(this.context, this.state); + this.enterRule(localContext, 30, ApexParser.RULE_constructorDeclaration); + try { + this.enterOuterAlt(localContext, 1); + { + this.state = 455; + this.qualifiedName(); + this.state = 456; + this.formalParameters(); + this.state = 457; + this.block(); + } + } + catch (re) { + if (re instanceof antlr.RecognitionException) { + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return localContext; + } + public fieldDeclaration(): FieldDeclarationContext { + const localContext = new FieldDeclarationContext(this.context, this.state); + this.enterRule(localContext, 32, ApexParser.RULE_fieldDeclaration); + try { + this.enterOuterAlt(localContext, 1); + { + this.state = 459; + this.typeRef(); + this.state = 460; + this.variableDeclarators(); + this.state = 461; + this.match(ApexParser.SEMI); + } + } + catch (re) { + if (re instanceof antlr.RecognitionException) { + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return localContext; + } + public propertyDeclaration(): PropertyDeclarationContext { + const localContext = new PropertyDeclarationContext(this.context, this.state); + this.enterRule(localContext, 34, ApexParser.RULE_propertyDeclaration); + let _la: number; + try { + this.enterOuterAlt(localContext, 1); + { + this.state = 463; + this.typeRef(); + this.state = 464; + this.id(); + this.state = 465; + this.match(ApexParser.LBRACE); + this.state = 469; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + while ((((_la) & ~0x1F) === 0 && ((1 << _la) & 4027785218) !== 0) || ((((_la - 34)) & ~0x1F) === 0 && ((1 << (_la - 34)) & 1655077) !== 0) || _la === 243) { + { + { + this.state = 466; + this.propertyBlock(); + } + } + this.state = 471; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + } + this.state = 472; + this.match(ApexParser.RBRACE); + } + } + catch (re) { + if (re instanceof antlr.RecognitionException) { + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return localContext; + } + public interfaceMethodDeclaration(): InterfaceMethodDeclarationContext { + const localContext = new InterfaceMethodDeclarationContext(this.context, this.state); + this.enterRule(localContext, 36, ApexParser.RULE_interfaceMethodDeclaration); + try { + let alternative: number; + this.enterOuterAlt(localContext, 1); + { + this.state = 477; + this.errorHandler.sync(this); + alternative = this.interpreter.adaptivePredict(this.tokenStream, 22, this.context); + while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) { + if (alternative === 1) { + { + { + this.state = 474; + this.modifier(); + } + } + } + this.state = 479; + this.errorHandler.sync(this); + alternative = this.interpreter.adaptivePredict(this.tokenStream, 22, this.context); + } + this.state = 482; + this.errorHandler.sync(this); + switch (this.tokenStream.LA(1)) { + case ApexParser.AFTER: + case ApexParser.BEFORE: + case ApexParser.GET: + case ApexParser.INHERITED: + case ApexParser.INSTANCEOF: + case ApexParser.SET: + case ApexParser.SHARING: + case ApexParser.SWITCH: + case ApexParser.TRANSIENT: + case ApexParser.TRIGGER: + case ApexParser.WHEN: + case ApexParser.WITH: + case ApexParser.WITHOUT: + case ApexParser.LIST: + case ApexParser.MAP: + case ApexParser.SYSTEM: + case ApexParser.USER: + case ApexParser.SELECT: + case ApexParser.COUNT: + case ApexParser.FROM: + case ApexParser.AS: + case ApexParser.USING: + case ApexParser.SCOPE: + case ApexParser.WHERE: + case ApexParser.ORDER: + case ApexParser.BY: + case ApexParser.LIMIT: + case ApexParser.SOQLAND: + case ApexParser.SOQLOR: + case ApexParser.NOT: + case ApexParser.AVG: + case ApexParser.COUNT_DISTINCT: + case ApexParser.MIN: + case ApexParser.MAX: + case ApexParser.SUM: + case ApexParser.TYPEOF: + case ApexParser.END: + case ApexParser.THEN: + case ApexParser.LIKE: + case ApexParser.IN: + case ApexParser.INCLUDES: + case ApexParser.EXCLUDES: + case ApexParser.ASC: + case ApexParser.DESC: + case ApexParser.NULLS: + case ApexParser.FIRST: + case ApexParser.LAST: + case ApexParser.GROUP: + case ApexParser.ALL: + case ApexParser.ROWS: + case ApexParser.VIEW: + case ApexParser.HAVING: + case ApexParser.ROLLUP: + case ApexParser.TOLABEL: + case ApexParser.OFFSET: + case ApexParser.DATA: + case ApexParser.CATEGORY: + case ApexParser.AT: + case ApexParser.ABOVE: + case ApexParser.BELOW: + case ApexParser.ABOVE_OR_BELOW: + case ApexParser.SECURITY_ENFORCED: + case ApexParser.SYSTEM_MODE: + case ApexParser.USER_MODE: + case ApexParser.REFERENCE: + case ApexParser.CUBE: + case ApexParser.FORMAT: + case ApexParser.TRACKING: + case ApexParser.VIEWSTAT: + case ApexParser.CUSTOM: + case ApexParser.STANDARD: + case ApexParser.DISTANCE: + case ApexParser.GEOLOCATION: + case ApexParser.CALENDAR_MONTH: + case ApexParser.CALENDAR_QUARTER: + case ApexParser.CALENDAR_YEAR: + case ApexParser.DAY_IN_MONTH: + case ApexParser.DAY_IN_WEEK: + case ApexParser.DAY_IN_YEAR: + case ApexParser.DAY_ONLY: + case ApexParser.FISCAL_MONTH: + case ApexParser.FISCAL_QUARTER: + case ApexParser.FISCAL_YEAR: + case ApexParser.HOUR_IN_DAY: + case ApexParser.WEEK_IN_MONTH: + case ApexParser.WEEK_IN_YEAR: + case ApexParser.CONVERT_TIMEZONE: + case ApexParser.YESTERDAY: + case ApexParser.TODAY: + case ApexParser.TOMORROW: + case ApexParser.LAST_WEEK: + case ApexParser.THIS_WEEK: + case ApexParser.NEXT_WEEK: + case ApexParser.LAST_MONTH: + case ApexParser.THIS_MONTH: + case ApexParser.NEXT_MONTH: + case ApexParser.LAST_90_DAYS: + case ApexParser.NEXT_90_DAYS: + case ApexParser.LAST_N_DAYS_N: + case ApexParser.NEXT_N_DAYS_N: + case ApexParser.N_DAYS_AGO_N: + case ApexParser.NEXT_N_WEEKS_N: + case ApexParser.LAST_N_WEEKS_N: + case ApexParser.N_WEEKS_AGO_N: + case ApexParser.NEXT_N_MONTHS_N: + case ApexParser.LAST_N_MONTHS_N: + case ApexParser.N_MONTHS_AGO_N: + case ApexParser.THIS_QUARTER: + case ApexParser.LAST_QUARTER: + case ApexParser.NEXT_QUARTER: + case ApexParser.NEXT_N_QUARTERS_N: + case ApexParser.LAST_N_QUARTERS_N: + case ApexParser.N_QUARTERS_AGO_N: + case ApexParser.THIS_YEAR: + case ApexParser.LAST_YEAR: + case ApexParser.NEXT_YEAR: + case ApexParser.NEXT_N_YEARS_N: + case ApexParser.LAST_N_YEARS_N: + case ApexParser.N_YEARS_AGO_N: + case ApexParser.THIS_FISCAL_QUARTER: + case ApexParser.LAST_FISCAL_QUARTER: + case ApexParser.NEXT_FISCAL_QUARTER: + case ApexParser.NEXT_N_FISCAL_QUARTERS_N: + case ApexParser.LAST_N_FISCAL_QUARTERS_N: + case ApexParser.N_FISCAL_QUARTERS_AGO_N: + case ApexParser.THIS_FISCAL_YEAR: + case ApexParser.LAST_FISCAL_YEAR: + case ApexParser.NEXT_FISCAL_YEAR: + case ApexParser.NEXT_N_FISCAL_YEARS_N: + case ApexParser.LAST_N_FISCAL_YEARS_N: + case ApexParser.N_FISCAL_YEARS_AGO_N: + case ApexParser.IntegralCurrencyLiteral: + case ApexParser.FIND: + case ApexParser.EMAIL: + case ApexParser.NAME: + case ApexParser.PHONE: + case ApexParser.SIDEBAR: + case ApexParser.FIELDS: + case ApexParser.METADATA: + case ApexParser.PRICEBOOKID: + case ApexParser.NETWORK: + case ApexParser.SNIPPET: + case ApexParser.TARGET_LENGTH: + case ApexParser.DIVISION: + case ApexParser.RETURNING: + case ApexParser.LISTVIEW: + case ApexParser.Identifier: + { + this.state = 480; + this.typeRef(); + } + break; + case ApexParser.VOID: + { + this.state = 481; + this.match(ApexParser.VOID); + } + break; + default: + throw new antlr.NoViableAltException(this); + } + this.state = 484; + this.id(); + this.state = 485; + this.formalParameters(); + this.state = 486; + this.match(ApexParser.SEMI); + } + } + catch (re) { + if (re instanceof antlr.RecognitionException) { + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return localContext; + } + public variableDeclarators(): VariableDeclaratorsContext { + const localContext = new VariableDeclaratorsContext(this.context, this.state); + this.enterRule(localContext, 38, ApexParser.RULE_variableDeclarators); + let _la: number; + try { + this.enterOuterAlt(localContext, 1); + { + this.state = 488; + this.variableDeclarator(); + this.state = 493; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + while (_la === 205) { + { + { + this.state = 489; + this.match(ApexParser.COMMA); + this.state = 490; + this.variableDeclarator(); + } + } + this.state = 495; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + } + } + } + catch (re) { + if (re instanceof antlr.RecognitionException) { + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return localContext; + } + public variableDeclarator(): VariableDeclaratorContext { + const localContext = new VariableDeclaratorContext(this.context, this.state); + this.enterRule(localContext, 40, ApexParser.RULE_variableDeclarator); + let _la: number; + try { + this.enterOuterAlt(localContext, 1); + { + this.state = 496; + this.id(); + this.state = 499; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 207) { + { + this.state = 497; + this.match(ApexParser.ASSIGN); + this.state = 498; + this.expression(0); + } + } + + } + } + catch (re) { + if (re instanceof antlr.RecognitionException) { + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return localContext; + } + public arrayInitializer(): ArrayInitializerContext { + const localContext = new ArrayInitializerContext(this.context, this.state); + this.enterRule(localContext, 42, ApexParser.RULE_arrayInitializer); + let _la: number; + try { + let alternative: number; + this.enterOuterAlt(localContext, 1); + { + this.state = 501; + this.match(ApexParser.LBRACE); + this.state = 513; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if ((((_la) & ~0x1F) === 0 && ((1 << _la) & 105971724) !== 0) || ((((_la - 34)) & ~0x1F) === 0 && ((1 << (_la - 34)) & 4294607707) !== 0) || ((((_la - 66)) & ~0x1F) === 0 && ((1 << (_la - 66)) & 4294967295) !== 0) || ((((_la - 98)) & ~0x1F) === 0 && ((1 << (_la - 98)) & 4294967295) !== 0) || ((((_la - 130)) & ~0x1F) === 0 && ((1 << (_la - 130)) & 4294967295) !== 0) || ((((_la - 162)) & ~0x1F) === 0 && ((1 << (_la - 162)) & 3758090239) !== 0) || ((((_la - 194)) & ~0x1F) === 0 && ((1 << (_la - 194)) & 3758293271) !== 0) || _la === 226 || _la === 244) { + { + this.state = 502; + this.expression(0); + this.state = 507; + this.errorHandler.sync(this); + alternative = this.interpreter.adaptivePredict(this.tokenStream, 26, this.context); + while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) { + if (alternative === 1) { + { + { + this.state = 503; + this.match(ApexParser.COMMA); + this.state = 504; + this.expression(0); + } + } + } + this.state = 509; + this.errorHandler.sync(this); + alternative = this.interpreter.adaptivePredict(this.tokenStream, 26, this.context); + } + this.state = 511; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 205) { + { + this.state = 510; + this.match(ApexParser.COMMA); + } + } + + } + } + + this.state = 515; + this.match(ApexParser.RBRACE); + } + } + catch (re) { + if (re instanceof antlr.RecognitionException) { + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return localContext; + } + public typeRef(): TypeRefContext { + const localContext = new TypeRefContext(this.context, this.state); + this.enterRule(localContext, 44, ApexParser.RULE_typeRef); + try { + let alternative: number; + this.enterOuterAlt(localContext, 1); + { + this.state = 517; + this.typeName(); + this.state = 522; + this.errorHandler.sync(this); + alternative = this.interpreter.adaptivePredict(this.tokenStream, 29, this.context); + while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) { + if (alternative === 1) { + { + { + this.state = 518; + this.match(ApexParser.DOT); + this.state = 519; + this.typeName(); + } + } + } + this.state = 524; + this.errorHandler.sync(this); + alternative = this.interpreter.adaptivePredict(this.tokenStream, 29, this.context); + } + this.state = 525; + this.arraySubscripts(); + } + } + catch (re) { + if (re instanceof antlr.RecognitionException) { + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return localContext; + } + public arraySubscripts(): ArraySubscriptsContext { + const localContext = new ArraySubscriptsContext(this.context, this.state); + this.enterRule(localContext, 46, ApexParser.RULE_arraySubscripts); + try { + let alternative: number; + this.enterOuterAlt(localContext, 1); + { + this.state = 531; + this.errorHandler.sync(this); + alternative = this.interpreter.adaptivePredict(this.tokenStream, 30, this.context); + while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) { + if (alternative === 1) { + { + { + this.state = 527; + this.match(ApexParser.LBRACK); + this.state = 528; + this.match(ApexParser.RBRACK); + } + } + } + this.state = 533; + this.errorHandler.sync(this); + alternative = this.interpreter.adaptivePredict(this.tokenStream, 30, this.context); + } + } + } + catch (re) { + if (re instanceof antlr.RecognitionException) { + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return localContext; + } + public typeName(): TypeNameContext { + const localContext = new TypeNameContext(this.context, this.state); + this.enterRule(localContext, 48, ApexParser.RULE_typeName); + try { + this.state = 550; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 35, this.context) ) { + case 1: + this.enterOuterAlt(localContext, 1); + { + this.state = 534; + this.match(ApexParser.LIST); + this.state = 536; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 31, this.context) ) { + case 1: + { + this.state = 535; + this.typeArguments(); + } + break; + } + } + break; + case 2: + this.enterOuterAlt(localContext, 2); + { + this.state = 538; + this.match(ApexParser.SET); + this.state = 540; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 32, this.context) ) { + case 1: + { + this.state = 539; + this.typeArguments(); + } + break; + } + } + break; + case 3: + this.enterOuterAlt(localContext, 3); + { + this.state = 542; + this.match(ApexParser.MAP); + this.state = 544; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 33, this.context) ) { + case 1: + { + this.state = 543; + this.typeArguments(); + } + break; + } + } + break; + case 4: + this.enterOuterAlt(localContext, 4); + { + this.state = 546; + this.id(); + this.state = 548; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 34, this.context) ) { + case 1: + { + this.state = 547; + this.typeArguments(); + } + break; + } + } + break; + } + } + catch (re) { + if (re instanceof antlr.RecognitionException) { + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return localContext; + } + public typeArguments(): TypeArgumentsContext { + const localContext = new TypeArgumentsContext(this.context, this.state); + this.enterRule(localContext, 50, ApexParser.RULE_typeArguments); + try { + this.enterOuterAlt(localContext, 1); + { + this.state = 552; + this.match(ApexParser.LT); + this.state = 553; + this.typeList(); + this.state = 554; + this.match(ApexParser.GT); + } + } + catch (re) { + if (re instanceof antlr.RecognitionException) { + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return localContext; + } + public formalParameters(): FormalParametersContext { + const localContext = new FormalParametersContext(this.context, this.state); + this.enterRule(localContext, 52, ApexParser.RULE_formalParameters); + let _la: number; + try { + this.enterOuterAlt(localContext, 1); + { + this.state = 556; + this.match(ApexParser.LPAREN); + this.state = 558; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if ((((_la) & ~0x1F) === 0 && ((1 << _la) & 4031979534) !== 0) || ((((_la - 34)) & ~0x1F) === 0 && ((1 << (_la - 34)) & 4294656823) !== 0) || ((((_la - 66)) & ~0x1F) === 0 && ((1 << (_la - 66)) & 4294967295) !== 0) || ((((_la - 98)) & ~0x1F) === 0 && ((1 << (_la - 98)) & 4294967295) !== 0) || ((((_la - 130)) & ~0x1F) === 0 && ((1 << (_la - 130)) & 4294967295) !== 0) || ((((_la - 162)) & ~0x1F) === 0 && ((1 << (_la - 162)) & 268429311) !== 0) || _la === 243 || _la === 244) { + { + this.state = 557; + this.formalParameterList(); + } + } + + this.state = 560; + this.match(ApexParser.RPAREN); + } + } + catch (re) { + if (re instanceof antlr.RecognitionException) { + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return localContext; + } + public formalParameterList(): FormalParameterListContext { + const localContext = new FormalParameterListContext(this.context, this.state); + this.enterRule(localContext, 54, ApexParser.RULE_formalParameterList); + let _la: number; + try { + this.enterOuterAlt(localContext, 1); + { + this.state = 562; + this.formalParameter(); + this.state = 567; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + while (_la === 205) { + { + { + this.state = 563; + this.match(ApexParser.COMMA); + this.state = 564; + this.formalParameter(); + } + } + this.state = 569; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + } + } + } + catch (re) { + if (re instanceof antlr.RecognitionException) { + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return localContext; + } + public formalParameter(): FormalParameterContext { + const localContext = new FormalParameterContext(this.context, this.state); + this.enterRule(localContext, 56, ApexParser.RULE_formalParameter); + try { + let alternative: number; + this.enterOuterAlt(localContext, 1); + { + this.state = 573; + this.errorHandler.sync(this); + alternative = this.interpreter.adaptivePredict(this.tokenStream, 38, this.context); + while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) { + if (alternative === 1) { + { + { + this.state = 570; + this.modifier(); + } + } + } + this.state = 575; + this.errorHandler.sync(this); + alternative = this.interpreter.adaptivePredict(this.tokenStream, 38, this.context); + } + this.state = 576; + this.typeRef(); + this.state = 577; + this.id(); + } + } + catch (re) { + if (re instanceof antlr.RecognitionException) { + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return localContext; + } + public qualifiedName(): QualifiedNameContext { + const localContext = new QualifiedNameContext(this.context, this.state); + this.enterRule(localContext, 58, ApexParser.RULE_qualifiedName); + let _la: number; + try { + this.enterOuterAlt(localContext, 1); + { + this.state = 579; + this.id(); + this.state = 584; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + while (_la === 206) { + { + { + this.state = 580; + this.match(ApexParser.DOT); + this.state = 581; + this.id(); + } + } + this.state = 586; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + } + } + } + catch (re) { + if (re instanceof antlr.RecognitionException) { + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return localContext; + } + public literal(): LiteralContext { + const localContext = new LiteralContext(this.context, this.state); + this.enterRule(localContext, 60, ApexParser.RULE_literal); + let _la: number; + try { + this.enterOuterAlt(localContext, 1); + { + this.state = 587; + _la = this.tokenStream.LA(1); + if(!(_la === 26 || ((((_la - 192)) & ~0x1F) === 0 && ((1 << (_la - 192)) & 31) !== 0))) { + this.errorHandler.recoverInline(this); + } + else { + this.errorHandler.reportMatch(this); + this.consume(); + } + } + } + catch (re) { + if (re instanceof antlr.RecognitionException) { + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return localContext; + } + public annotation(): AnnotationContext { + const localContext = new AnnotationContext(this.context, this.state); + this.enterRule(localContext, 62, ApexParser.RULE_annotation); + let _la: number; + try { + this.enterOuterAlt(localContext, 1); + { + this.state = 589; + this.match(ApexParser.ATSIGN); + this.state = 590; + this.qualifiedName(); + this.state = 597; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 198) { + { + this.state = 591; + this.match(ApexParser.LPAREN); + this.state = 594; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 40, this.context) ) { + case 1: + { + this.state = 592; + this.elementValuePairs(); + } + break; + case 2: + { + this.state = 593; + this.elementValue(); + } + break; + } + this.state = 596; + this.match(ApexParser.RPAREN); + } + } + + } + } + catch (re) { + if (re instanceof antlr.RecognitionException) { + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return localContext; + } + public elementValuePairs(): ElementValuePairsContext { + const localContext = new ElementValuePairsContext(this.context, this.state); + this.enterRule(localContext, 64, ApexParser.RULE_elementValuePairs); + let _la: number; + try { + this.enterOuterAlt(localContext, 1); + { + this.state = 599; + this.elementValuePair(); + this.state = 606; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + while ((((_la) & ~0x1F) === 0 && ((1 << _la) & 5308428) !== 0) || ((((_la - 34)) & ~0x1F) === 0 && ((1 << (_la - 34)) & 4288283411) !== 0) || ((((_la - 66)) & ~0x1F) === 0 && ((1 << (_la - 66)) & 4294967295) !== 0) || ((((_la - 98)) & ~0x1F) === 0 && ((1 << (_la - 98)) & 4294967295) !== 0) || ((((_la - 130)) & ~0x1F) === 0 && ((1 << (_la - 130)) & 4294967295) !== 0) || ((((_la - 162)) & ~0x1F) === 0 && ((1 << (_la - 162)) & 268429311) !== 0) || _la === 205 || _la === 244) { + { + { + this.state = 601; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 205) { + { + this.state = 600; + this.match(ApexParser.COMMA); + } + } + + this.state = 603; + this.elementValuePair(); + } + } + this.state = 608; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + } + } + } + catch (re) { + if (re instanceof antlr.RecognitionException) { + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return localContext; + } + public elementValuePair(): ElementValuePairContext { + const localContext = new ElementValuePairContext(this.context, this.state); + this.enterRule(localContext, 66, ApexParser.RULE_elementValuePair); + try { + this.enterOuterAlt(localContext, 1); + { + this.state = 609; + this.id(); + this.state = 610; + this.match(ApexParser.ASSIGN); + this.state = 611; + this.elementValue(); + } + } + catch (re) { + if (re instanceof antlr.RecognitionException) { + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return localContext; + } + public elementValue(): ElementValueContext { + const localContext = new ElementValueContext(this.context, this.state); + this.enterRule(localContext, 68, ApexParser.RULE_elementValue); + try { + this.state = 616; + this.errorHandler.sync(this); + switch (this.tokenStream.LA(1)) { + case ApexParser.AFTER: + case ApexParser.BEFORE: + case ApexParser.GET: + case ApexParser.INHERITED: + case ApexParser.INSTANCEOF: + case ApexParser.NEW: + case ApexParser.NULL: + case ApexParser.SET: + case ApexParser.SHARING: + case ApexParser.SUPER: + case ApexParser.SWITCH: + case ApexParser.THIS: + case ApexParser.TRANSIENT: + case ApexParser.TRIGGER: + case ApexParser.VOID: + case ApexParser.WHEN: + case ApexParser.WITH: + case ApexParser.WITHOUT: + case ApexParser.LIST: + case ApexParser.MAP: + case ApexParser.SYSTEM: + case ApexParser.USER: + case ApexParser.SELECT: + case ApexParser.COUNT: + case ApexParser.FROM: + case ApexParser.AS: + case ApexParser.USING: + case ApexParser.SCOPE: + case ApexParser.WHERE: + case ApexParser.ORDER: + case ApexParser.BY: + case ApexParser.LIMIT: + case ApexParser.SOQLAND: + case ApexParser.SOQLOR: + case ApexParser.NOT: + case ApexParser.AVG: + case ApexParser.COUNT_DISTINCT: + case ApexParser.MIN: + case ApexParser.MAX: + case ApexParser.SUM: + case ApexParser.TYPEOF: + case ApexParser.END: + case ApexParser.THEN: + case ApexParser.LIKE: + case ApexParser.IN: + case ApexParser.INCLUDES: + case ApexParser.EXCLUDES: + case ApexParser.ASC: + case ApexParser.DESC: + case ApexParser.NULLS: + case ApexParser.FIRST: + case ApexParser.LAST: + case ApexParser.GROUP: + case ApexParser.ALL: + case ApexParser.ROWS: + case ApexParser.VIEW: + case ApexParser.HAVING: + case ApexParser.ROLLUP: + case ApexParser.TOLABEL: + case ApexParser.OFFSET: + case ApexParser.DATA: + case ApexParser.CATEGORY: + case ApexParser.AT: + case ApexParser.ABOVE: + case ApexParser.BELOW: + case ApexParser.ABOVE_OR_BELOW: + case ApexParser.SECURITY_ENFORCED: + case ApexParser.SYSTEM_MODE: + case ApexParser.USER_MODE: + case ApexParser.REFERENCE: + case ApexParser.CUBE: + case ApexParser.FORMAT: + case ApexParser.TRACKING: + case ApexParser.VIEWSTAT: + case ApexParser.CUSTOM: + case ApexParser.STANDARD: + case ApexParser.DISTANCE: + case ApexParser.GEOLOCATION: + case ApexParser.CALENDAR_MONTH: + case ApexParser.CALENDAR_QUARTER: + case ApexParser.CALENDAR_YEAR: + case ApexParser.DAY_IN_MONTH: + case ApexParser.DAY_IN_WEEK: + case ApexParser.DAY_IN_YEAR: + case ApexParser.DAY_ONLY: + case ApexParser.FISCAL_MONTH: + case ApexParser.FISCAL_QUARTER: + case ApexParser.FISCAL_YEAR: + case ApexParser.HOUR_IN_DAY: + case ApexParser.WEEK_IN_MONTH: + case ApexParser.WEEK_IN_YEAR: + case ApexParser.CONVERT_TIMEZONE: + case ApexParser.YESTERDAY: + case ApexParser.TODAY: + case ApexParser.TOMORROW: + case ApexParser.LAST_WEEK: + case ApexParser.THIS_WEEK: + case ApexParser.NEXT_WEEK: + case ApexParser.LAST_MONTH: + case ApexParser.THIS_MONTH: + case ApexParser.NEXT_MONTH: + case ApexParser.LAST_90_DAYS: + case ApexParser.NEXT_90_DAYS: + case ApexParser.LAST_N_DAYS_N: + case ApexParser.NEXT_N_DAYS_N: + case ApexParser.N_DAYS_AGO_N: + case ApexParser.NEXT_N_WEEKS_N: + case ApexParser.LAST_N_WEEKS_N: + case ApexParser.N_WEEKS_AGO_N: + case ApexParser.NEXT_N_MONTHS_N: + case ApexParser.LAST_N_MONTHS_N: + case ApexParser.N_MONTHS_AGO_N: + case ApexParser.THIS_QUARTER: + case ApexParser.LAST_QUARTER: + case ApexParser.NEXT_QUARTER: + case ApexParser.NEXT_N_QUARTERS_N: + case ApexParser.LAST_N_QUARTERS_N: + case ApexParser.N_QUARTERS_AGO_N: + case ApexParser.THIS_YEAR: + case ApexParser.LAST_YEAR: + case ApexParser.NEXT_YEAR: + case ApexParser.NEXT_N_YEARS_N: + case ApexParser.LAST_N_YEARS_N: + case ApexParser.N_YEARS_AGO_N: + case ApexParser.THIS_FISCAL_QUARTER: + case ApexParser.LAST_FISCAL_QUARTER: + case ApexParser.NEXT_FISCAL_QUARTER: + case ApexParser.NEXT_N_FISCAL_QUARTERS_N: + case ApexParser.LAST_N_FISCAL_QUARTERS_N: + case ApexParser.N_FISCAL_QUARTERS_AGO_N: + case ApexParser.THIS_FISCAL_YEAR: + case ApexParser.LAST_FISCAL_YEAR: + case ApexParser.NEXT_FISCAL_YEAR: + case ApexParser.NEXT_N_FISCAL_YEARS_N: + case ApexParser.LAST_N_FISCAL_YEARS_N: + case ApexParser.N_FISCAL_YEARS_AGO_N: + case ApexParser.IntegralCurrencyLiteral: + case ApexParser.FIND: + case ApexParser.EMAIL: + case ApexParser.NAME: + case ApexParser.PHONE: + case ApexParser.SIDEBAR: + case ApexParser.FIELDS: + case ApexParser.METADATA: + case ApexParser.PRICEBOOKID: + case ApexParser.NETWORK: + case ApexParser.SNIPPET: + case ApexParser.TARGET_LENGTH: + case ApexParser.DIVISION: + case ApexParser.RETURNING: + case ApexParser.LISTVIEW: + case ApexParser.FindLiteral: + case ApexParser.IntegerLiteral: + case ApexParser.LongLiteral: + case ApexParser.NumberLiteral: + case ApexParser.BooleanLiteral: + case ApexParser.StringLiteral: + case ApexParser.LPAREN: + case ApexParser.LBRACK: + case ApexParser.BANG: + case ApexParser.TILDE: + case ApexParser.INC: + case ApexParser.DEC: + case ApexParser.ADD: + case ApexParser.SUB: + case ApexParser.Identifier: + this.enterOuterAlt(localContext, 1); + { + this.state = 613; + this.expression(0); + } + break; + case ApexParser.ATSIGN: + this.enterOuterAlt(localContext, 2); + { + this.state = 614; + this.annotation(); + } + break; + case ApexParser.LBRACE: + this.enterOuterAlt(localContext, 3); + { + this.state = 615; + this.elementValueArrayInitializer(); + } + break; + default: + throw new antlr.NoViableAltException(this); + } + } + catch (re) { + if (re instanceof antlr.RecognitionException) { + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return localContext; + } + public elementValueArrayInitializer(): ElementValueArrayInitializerContext { + const localContext = new ElementValueArrayInitializerContext(this.context, this.state); + this.enterRule(localContext, 70, ApexParser.RULE_elementValueArrayInitializer); + let _la: number; + try { + let alternative: number; + this.enterOuterAlt(localContext, 1); + { + this.state = 618; + this.match(ApexParser.LBRACE); + this.state = 627; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if ((((_la) & ~0x1F) === 0 && ((1 << _la) & 105971724) !== 0) || ((((_la - 34)) & ~0x1F) === 0 && ((1 << (_la - 34)) & 4294607707) !== 0) || ((((_la - 66)) & ~0x1F) === 0 && ((1 << (_la - 66)) & 4294967295) !== 0) || ((((_la - 98)) & ~0x1F) === 0 && ((1 << (_la - 98)) & 4294967295) !== 0) || ((((_la - 130)) & ~0x1F) === 0 && ((1 << (_la - 130)) & 4294967295) !== 0) || ((((_la - 162)) & ~0x1F) === 0 && ((1 << (_la - 162)) & 3758090239) !== 0) || ((((_la - 194)) & ~0x1F) === 0 && ((1 << (_la - 194)) & 3758293335) !== 0) || ((((_la - 226)) & ~0x1F) === 0 && ((1 << (_la - 226)) & 393217) !== 0)) { + { + this.state = 619; + this.elementValue(); + this.state = 624; + this.errorHandler.sync(this); + alternative = this.interpreter.adaptivePredict(this.tokenStream, 45, this.context); + while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) { + if (alternative === 1) { + { + { + this.state = 620; + this.match(ApexParser.COMMA); + this.state = 621; + this.elementValue(); + } + } + } + this.state = 626; + this.errorHandler.sync(this); + alternative = this.interpreter.adaptivePredict(this.tokenStream, 45, this.context); + } + } + } + + this.state = 630; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 205) { + { + this.state = 629; + this.match(ApexParser.COMMA); + } + } + + this.state = 632; + this.match(ApexParser.RBRACE); + } + } + catch (re) { + if (re instanceof antlr.RecognitionException) { + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return localContext; + } + public block(): BlockContext { + const localContext = new BlockContext(this.context, this.state); + this.enterRule(localContext, 72, ApexParser.RULE_block); + let _la: number; + try { + this.enterOuterAlt(localContext, 1); + { + this.state = 634; + this.match(ApexParser.LBRACE); + this.state = 638; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + while ((((_la) & ~0x1F) === 0 && ((1 << _la) & 4151813022) !== 0) || ((((_la - 32)) & ~0x1F) === 0 && ((1 << (_la - 32)) & 4294967295) !== 0) || ((((_la - 64)) & ~0x1F) === 0 && ((1 << (_la - 64)) & 4294967295) !== 0) || ((((_la - 96)) & ~0x1F) === 0 && ((1 << (_la - 96)) & 4294967295) !== 0) || ((((_la - 128)) & ~0x1F) === 0 && ((1 << (_la - 128)) & 4294967295) !== 0) || ((((_la - 160)) & ~0x1F) === 0 && ((1 << (_la - 160)) & 2147459071) !== 0) || ((((_la - 192)) & ~0x1F) === 0 && ((1 << (_la - 192)) & 2148271455) !== 0) || ((((_la - 224)) & ~0x1F) === 0 && ((1 << (_la - 224)) & 1572871) !== 0)) { + { + { + this.state = 635; + this.statement(); + } + } + this.state = 640; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + } + this.state = 641; + this.match(ApexParser.RBRACE); + } + } + catch (re) { + if (re instanceof antlr.RecognitionException) { + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return localContext; + } + public localVariableDeclarationStatement(): LocalVariableDeclarationStatementContext { + const localContext = new LocalVariableDeclarationStatementContext(this.context, this.state); + this.enterRule(localContext, 74, ApexParser.RULE_localVariableDeclarationStatement); + try { + this.enterOuterAlt(localContext, 1); + { + this.state = 643; + this.localVariableDeclaration(); + this.state = 644; + this.match(ApexParser.SEMI); + } + } + catch (re) { + if (re instanceof antlr.RecognitionException) { + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return localContext; + } + public localVariableDeclaration(): LocalVariableDeclarationContext { + const localContext = new LocalVariableDeclarationContext(this.context, this.state); + this.enterRule(localContext, 76, ApexParser.RULE_localVariableDeclaration); + try { + let alternative: number; + this.enterOuterAlt(localContext, 1); + { + this.state = 649; + this.errorHandler.sync(this); + alternative = this.interpreter.adaptivePredict(this.tokenStream, 49, this.context); + while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) { + if (alternative === 1) { + { + { + this.state = 646; + this.modifier(); + } + } + } + this.state = 651; + this.errorHandler.sync(this); + alternative = this.interpreter.adaptivePredict(this.tokenStream, 49, this.context); + } + this.state = 652; + this.typeRef(); + this.state = 653; + this.variableDeclarators(); + } + } + catch (re) { + if (re instanceof antlr.RecognitionException) { + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return localContext; + } + public statement(): StatementContext { + const localContext = new StatementContext(this.context, this.state); + this.enterRule(localContext, 78, ApexParser.RULE_statement); + try { + this.state = 675; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 50, this.context) ) { + case 1: + this.enterOuterAlt(localContext, 1); + { + this.state = 655; + this.block(); + } + break; + case 2: + this.enterOuterAlt(localContext, 2); + { + this.state = 656; + this.ifStatement(); + } + break; + case 3: + this.enterOuterAlt(localContext, 3); + { + this.state = 657; + this.switchStatement(); + } + break; + case 4: + this.enterOuterAlt(localContext, 4); + { + this.state = 658; + this.forStatement(); + } + break; + case 5: + this.enterOuterAlt(localContext, 5); + { + this.state = 659; + this.whileStatement(); + } + break; + case 6: + this.enterOuterAlt(localContext, 6); + { + this.state = 660; + this.doWhileStatement(); + } + break; + case 7: + this.enterOuterAlt(localContext, 7); + { + this.state = 661; + this.tryStatement(); + } + break; + case 8: + this.enterOuterAlt(localContext, 8); + { + this.state = 662; + this.returnStatement(); + } + break; + case 9: + this.enterOuterAlt(localContext, 9); + { + this.state = 663; + this.throwStatement(); + } + break; + case 10: + this.enterOuterAlt(localContext, 10); + { + this.state = 664; + this.breakStatement(); + } + break; + case 11: + this.enterOuterAlt(localContext, 11); + { + this.state = 665; + this.continueStatement(); + } + break; + case 12: + this.enterOuterAlt(localContext, 12); + { + this.state = 666; + this.insertStatement(); + } + break; + case 13: + this.enterOuterAlt(localContext, 13); + { + this.state = 667; + this.updateStatement(); + } + break; + case 14: + this.enterOuterAlt(localContext, 14); + { + this.state = 668; + this.deleteStatement(); + } + break; + case 15: + this.enterOuterAlt(localContext, 15); + { + this.state = 669; + this.undeleteStatement(); + } + break; + case 16: + this.enterOuterAlt(localContext, 16); + { + this.state = 670; + this.upsertStatement(); + } + break; + case 17: + this.enterOuterAlt(localContext, 17); + { + this.state = 671; + this.mergeStatement(); + } + break; + case 18: + this.enterOuterAlt(localContext, 18); + { + this.state = 672; + this.runAsStatement(); + } + break; + case 19: + this.enterOuterAlt(localContext, 19); + { + this.state = 673; + this.localVariableDeclarationStatement(); + } + break; + case 20: + this.enterOuterAlt(localContext, 20); + { + this.state = 674; + this.expressionStatement(); + } + break; + } + } + catch (re) { + if (re instanceof antlr.RecognitionException) { + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return localContext; + } + public ifStatement(): IfStatementContext { + const localContext = new IfStatementContext(this.context, this.state); + this.enterRule(localContext, 80, ApexParser.RULE_ifStatement); + try { + this.enterOuterAlt(localContext, 1); + { + this.state = 677; + this.match(ApexParser.IF); + this.state = 678; + this.parExpression(); + this.state = 679; + this.statement(); + this.state = 682; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 51, this.context) ) { + case 1: + { + this.state = 680; + this.match(ApexParser.ELSE); + this.state = 681; + this.statement(); + } + break; + } + } + } + catch (re) { + if (re instanceof antlr.RecognitionException) { + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return localContext; + } + public switchStatement(): SwitchStatementContext { + const localContext = new SwitchStatementContext(this.context, this.state); + this.enterRule(localContext, 82, ApexParser.RULE_switchStatement); + let _la: number; + try { + this.enterOuterAlt(localContext, 1); + { + this.state = 684; + this.match(ApexParser.SWITCH); + this.state = 685; + this.match(ApexParser.ON); + this.state = 686; + this.expression(0); + this.state = 687; + this.match(ApexParser.LBRACE); + this.state = 689; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + do { + { + { + this.state = 688; + this.whenControl(); + } + } + this.state = 691; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + } while (_la === 51); + this.state = 693; + this.match(ApexParser.RBRACE); + } + } + catch (re) { + if (re instanceof antlr.RecognitionException) { + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return localContext; + } + public whenControl(): WhenControlContext { + const localContext = new WhenControlContext(this.context, this.state); + this.enterRule(localContext, 84, ApexParser.RULE_whenControl); + try { + this.enterOuterAlt(localContext, 1); + { + this.state = 695; + this.match(ApexParser.WHEN); + this.state = 696; + this.whenValue(); + this.state = 697; + this.block(); + } + } + catch (re) { + if (re instanceof antlr.RecognitionException) { + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return localContext; + } + public whenValue(): WhenValueContext { + const localContext = new WhenValueContext(this.context, this.state); + this.enterRule(localContext, 86, ApexParser.RULE_whenValue); + let _la: number; + try { + this.state = 711; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 54, this.context) ) { + case 1: + this.enterOuterAlt(localContext, 1); + { + this.state = 699; + this.match(ApexParser.ELSE); + } + break; + case 2: + this.enterOuterAlt(localContext, 2); + { + this.state = 700; + this.whenLiteral(); + this.state = 705; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + while (_la === 205) { + { + { + this.state = 701; + this.match(ApexParser.COMMA); + this.state = 702; + this.whenLiteral(); + } + } + this.state = 707; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + } + } + break; + case 3: + this.enterOuterAlt(localContext, 3); + { + this.state = 708; + this.id(); + this.state = 709; + this.id(); + } + break; + } + } + catch (re) { + if (re instanceof antlr.RecognitionException) { + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return localContext; + } + public whenLiteral(): WhenLiteralContext { + const localContext = new WhenLiteralContext(this.context, this.state); + this.enterRule(localContext, 88, ApexParser.RULE_whenLiteral); + let _la: number; + try { + this.state = 725; + this.errorHandler.sync(this); + switch (this.tokenStream.LA(1)) { + case ApexParser.IntegerLiteral: + case ApexParser.SUB: + this.enterOuterAlt(localContext, 1); + { + this.state = 714; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 226) { + { + this.state = 713; + this.match(ApexParser.SUB); + } + } + + this.state = 716; + this.match(ApexParser.IntegerLiteral); + } + break; + case ApexParser.LongLiteral: + this.enterOuterAlt(localContext, 2); + { + this.state = 717; + this.match(ApexParser.LongLiteral); + } + break; + case ApexParser.StringLiteral: + this.enterOuterAlt(localContext, 3); + { + this.state = 718; + this.match(ApexParser.StringLiteral); + } + break; + case ApexParser.NULL: + this.enterOuterAlt(localContext, 4); + { + this.state = 719; + this.match(ApexParser.NULL); + } + break; + case ApexParser.AFTER: + case ApexParser.BEFORE: + case ApexParser.GET: + case ApexParser.INHERITED: + case ApexParser.INSTANCEOF: + case ApexParser.SET: + case ApexParser.SHARING: + case ApexParser.SWITCH: + case ApexParser.TRANSIENT: + case ApexParser.TRIGGER: + case ApexParser.WHEN: + case ApexParser.WITH: + case ApexParser.WITHOUT: + case ApexParser.SYSTEM: + case ApexParser.USER: + case ApexParser.SELECT: + case ApexParser.COUNT: + case ApexParser.FROM: + case ApexParser.AS: + case ApexParser.USING: + case ApexParser.SCOPE: + case ApexParser.WHERE: + case ApexParser.ORDER: + case ApexParser.BY: + case ApexParser.LIMIT: + case ApexParser.SOQLAND: + case ApexParser.SOQLOR: + case ApexParser.NOT: + case ApexParser.AVG: + case ApexParser.COUNT_DISTINCT: + case ApexParser.MIN: + case ApexParser.MAX: + case ApexParser.SUM: + case ApexParser.TYPEOF: + case ApexParser.END: + case ApexParser.THEN: + case ApexParser.LIKE: + case ApexParser.IN: + case ApexParser.INCLUDES: + case ApexParser.EXCLUDES: + case ApexParser.ASC: + case ApexParser.DESC: + case ApexParser.NULLS: + case ApexParser.FIRST: + case ApexParser.LAST: + case ApexParser.GROUP: + case ApexParser.ALL: + case ApexParser.ROWS: + case ApexParser.VIEW: + case ApexParser.HAVING: + case ApexParser.ROLLUP: + case ApexParser.TOLABEL: + case ApexParser.OFFSET: + case ApexParser.DATA: + case ApexParser.CATEGORY: + case ApexParser.AT: + case ApexParser.ABOVE: + case ApexParser.BELOW: + case ApexParser.ABOVE_OR_BELOW: + case ApexParser.SECURITY_ENFORCED: + case ApexParser.SYSTEM_MODE: + case ApexParser.USER_MODE: + case ApexParser.REFERENCE: + case ApexParser.CUBE: + case ApexParser.FORMAT: + case ApexParser.TRACKING: + case ApexParser.VIEWSTAT: + case ApexParser.CUSTOM: + case ApexParser.STANDARD: + case ApexParser.DISTANCE: + case ApexParser.GEOLOCATION: + case ApexParser.CALENDAR_MONTH: + case ApexParser.CALENDAR_QUARTER: + case ApexParser.CALENDAR_YEAR: + case ApexParser.DAY_IN_MONTH: + case ApexParser.DAY_IN_WEEK: + case ApexParser.DAY_IN_YEAR: + case ApexParser.DAY_ONLY: + case ApexParser.FISCAL_MONTH: + case ApexParser.FISCAL_QUARTER: + case ApexParser.FISCAL_YEAR: + case ApexParser.HOUR_IN_DAY: + case ApexParser.WEEK_IN_MONTH: + case ApexParser.WEEK_IN_YEAR: + case ApexParser.CONVERT_TIMEZONE: + case ApexParser.YESTERDAY: + case ApexParser.TODAY: + case ApexParser.TOMORROW: + case ApexParser.LAST_WEEK: + case ApexParser.THIS_WEEK: + case ApexParser.NEXT_WEEK: + case ApexParser.LAST_MONTH: + case ApexParser.THIS_MONTH: + case ApexParser.NEXT_MONTH: + case ApexParser.LAST_90_DAYS: + case ApexParser.NEXT_90_DAYS: + case ApexParser.LAST_N_DAYS_N: + case ApexParser.NEXT_N_DAYS_N: + case ApexParser.N_DAYS_AGO_N: + case ApexParser.NEXT_N_WEEKS_N: + case ApexParser.LAST_N_WEEKS_N: + case ApexParser.N_WEEKS_AGO_N: + case ApexParser.NEXT_N_MONTHS_N: + case ApexParser.LAST_N_MONTHS_N: + case ApexParser.N_MONTHS_AGO_N: + case ApexParser.THIS_QUARTER: + case ApexParser.LAST_QUARTER: + case ApexParser.NEXT_QUARTER: + case ApexParser.NEXT_N_QUARTERS_N: + case ApexParser.LAST_N_QUARTERS_N: + case ApexParser.N_QUARTERS_AGO_N: + case ApexParser.THIS_YEAR: + case ApexParser.LAST_YEAR: + case ApexParser.NEXT_YEAR: + case ApexParser.NEXT_N_YEARS_N: + case ApexParser.LAST_N_YEARS_N: + case ApexParser.N_YEARS_AGO_N: + case ApexParser.THIS_FISCAL_QUARTER: + case ApexParser.LAST_FISCAL_QUARTER: + case ApexParser.NEXT_FISCAL_QUARTER: + case ApexParser.NEXT_N_FISCAL_QUARTERS_N: + case ApexParser.LAST_N_FISCAL_QUARTERS_N: + case ApexParser.N_FISCAL_QUARTERS_AGO_N: + case ApexParser.THIS_FISCAL_YEAR: + case ApexParser.LAST_FISCAL_YEAR: + case ApexParser.NEXT_FISCAL_YEAR: + case ApexParser.NEXT_N_FISCAL_YEARS_N: + case ApexParser.LAST_N_FISCAL_YEARS_N: + case ApexParser.N_FISCAL_YEARS_AGO_N: + case ApexParser.IntegralCurrencyLiteral: + case ApexParser.FIND: + case ApexParser.EMAIL: + case ApexParser.NAME: + case ApexParser.PHONE: + case ApexParser.SIDEBAR: + case ApexParser.FIELDS: + case ApexParser.METADATA: + case ApexParser.PRICEBOOKID: + case ApexParser.NETWORK: + case ApexParser.SNIPPET: + case ApexParser.TARGET_LENGTH: + case ApexParser.DIVISION: + case ApexParser.RETURNING: + case ApexParser.LISTVIEW: + case ApexParser.Identifier: + this.enterOuterAlt(localContext, 5); + { + this.state = 720; + this.id(); + } + break; + case ApexParser.LPAREN: + this.enterOuterAlt(localContext, 6); + { + this.state = 721; + this.match(ApexParser.LPAREN); + this.state = 722; + this.whenLiteral(); + this.state = 723; + this.match(ApexParser.RPAREN); + } + break; + default: + throw new antlr.NoViableAltException(this); + } + } + catch (re) { + if (re instanceof antlr.RecognitionException) { + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return localContext; + } + public forStatement(): ForStatementContext { + const localContext = new ForStatementContext(this.context, this.state); + this.enterRule(localContext, 90, ApexParser.RULE_forStatement); + try { + this.enterOuterAlt(localContext, 1); + { + this.state = 727; + this.match(ApexParser.FOR); + this.state = 728; + this.match(ApexParser.LPAREN); + this.state = 729; + this.forControl(); + this.state = 730; + this.match(ApexParser.RPAREN); + this.state = 733; + this.errorHandler.sync(this); + switch (this.tokenStream.LA(1)) { + case ApexParser.ABSTRACT: + case ApexParser.AFTER: + case ApexParser.BEFORE: + case ApexParser.BREAK: + case ApexParser.CONTINUE: + case ApexParser.DELETE: + case ApexParser.DO: + case ApexParser.FINAL: + case ApexParser.FOR: + case ApexParser.GET: + case ApexParser.GLOBAL: + case ApexParser.IF: + case ApexParser.INHERITED: + case ApexParser.INSERT: + case ApexParser.INSTANCEOF: + case ApexParser.MERGE: + case ApexParser.NEW: + case ApexParser.NULL: + case ApexParser.OVERRIDE: + case ApexParser.PRIVATE: + case ApexParser.PROTECTED: + case ApexParser.PUBLIC: + case ApexParser.RETURN: + case ApexParser.SYSTEMRUNAS: + case ApexParser.SET: + case ApexParser.SHARING: + case ApexParser.STATIC: + case ApexParser.SUPER: + case ApexParser.SWITCH: + case ApexParser.TESTMETHOD: + case ApexParser.THIS: + case ApexParser.THROW: + case ApexParser.TRANSIENT: + case ApexParser.TRIGGER: + case ApexParser.TRY: + case ApexParser.UNDELETE: + case ApexParser.UPDATE: + case ApexParser.UPSERT: + case ApexParser.VIRTUAL: + case ApexParser.VOID: + case ApexParser.WEBSERVICE: + case ApexParser.WHEN: + case ApexParser.WHILE: + case ApexParser.WITH: + case ApexParser.WITHOUT: + case ApexParser.LIST: + case ApexParser.MAP: + case ApexParser.SYSTEM: + case ApexParser.USER: + case ApexParser.SELECT: + case ApexParser.COUNT: + case ApexParser.FROM: + case ApexParser.AS: + case ApexParser.USING: + case ApexParser.SCOPE: + case ApexParser.WHERE: + case ApexParser.ORDER: + case ApexParser.BY: + case ApexParser.LIMIT: + case ApexParser.SOQLAND: + case ApexParser.SOQLOR: + case ApexParser.NOT: + case ApexParser.AVG: + case ApexParser.COUNT_DISTINCT: + case ApexParser.MIN: + case ApexParser.MAX: + case ApexParser.SUM: + case ApexParser.TYPEOF: + case ApexParser.END: + case ApexParser.THEN: + case ApexParser.LIKE: + case ApexParser.IN: + case ApexParser.INCLUDES: + case ApexParser.EXCLUDES: + case ApexParser.ASC: + case ApexParser.DESC: + case ApexParser.NULLS: + case ApexParser.FIRST: + case ApexParser.LAST: + case ApexParser.GROUP: + case ApexParser.ALL: + case ApexParser.ROWS: + case ApexParser.VIEW: + case ApexParser.HAVING: + case ApexParser.ROLLUP: + case ApexParser.TOLABEL: + case ApexParser.OFFSET: + case ApexParser.DATA: + case ApexParser.CATEGORY: + case ApexParser.AT: + case ApexParser.ABOVE: + case ApexParser.BELOW: + case ApexParser.ABOVE_OR_BELOW: + case ApexParser.SECURITY_ENFORCED: + case ApexParser.SYSTEM_MODE: + case ApexParser.USER_MODE: + case ApexParser.REFERENCE: + case ApexParser.CUBE: + case ApexParser.FORMAT: + case ApexParser.TRACKING: + case ApexParser.VIEWSTAT: + case ApexParser.CUSTOM: + case ApexParser.STANDARD: + case ApexParser.DISTANCE: + case ApexParser.GEOLOCATION: + case ApexParser.CALENDAR_MONTH: + case ApexParser.CALENDAR_QUARTER: + case ApexParser.CALENDAR_YEAR: + case ApexParser.DAY_IN_MONTH: + case ApexParser.DAY_IN_WEEK: + case ApexParser.DAY_IN_YEAR: + case ApexParser.DAY_ONLY: + case ApexParser.FISCAL_MONTH: + case ApexParser.FISCAL_QUARTER: + case ApexParser.FISCAL_YEAR: + case ApexParser.HOUR_IN_DAY: + case ApexParser.WEEK_IN_MONTH: + case ApexParser.WEEK_IN_YEAR: + case ApexParser.CONVERT_TIMEZONE: + case ApexParser.YESTERDAY: + case ApexParser.TODAY: + case ApexParser.TOMORROW: + case ApexParser.LAST_WEEK: + case ApexParser.THIS_WEEK: + case ApexParser.NEXT_WEEK: + case ApexParser.LAST_MONTH: + case ApexParser.THIS_MONTH: + case ApexParser.NEXT_MONTH: + case ApexParser.LAST_90_DAYS: + case ApexParser.NEXT_90_DAYS: + case ApexParser.LAST_N_DAYS_N: + case ApexParser.NEXT_N_DAYS_N: + case ApexParser.N_DAYS_AGO_N: + case ApexParser.NEXT_N_WEEKS_N: + case ApexParser.LAST_N_WEEKS_N: + case ApexParser.N_WEEKS_AGO_N: + case ApexParser.NEXT_N_MONTHS_N: + case ApexParser.LAST_N_MONTHS_N: + case ApexParser.N_MONTHS_AGO_N: + case ApexParser.THIS_QUARTER: + case ApexParser.LAST_QUARTER: + case ApexParser.NEXT_QUARTER: + case ApexParser.NEXT_N_QUARTERS_N: + case ApexParser.LAST_N_QUARTERS_N: + case ApexParser.N_QUARTERS_AGO_N: + case ApexParser.THIS_YEAR: + case ApexParser.LAST_YEAR: + case ApexParser.NEXT_YEAR: + case ApexParser.NEXT_N_YEARS_N: + case ApexParser.LAST_N_YEARS_N: + case ApexParser.N_YEARS_AGO_N: + case ApexParser.THIS_FISCAL_QUARTER: + case ApexParser.LAST_FISCAL_QUARTER: + case ApexParser.NEXT_FISCAL_QUARTER: + case ApexParser.NEXT_N_FISCAL_QUARTERS_N: + case ApexParser.LAST_N_FISCAL_QUARTERS_N: + case ApexParser.N_FISCAL_QUARTERS_AGO_N: + case ApexParser.THIS_FISCAL_YEAR: + case ApexParser.LAST_FISCAL_YEAR: + case ApexParser.NEXT_FISCAL_YEAR: + case ApexParser.NEXT_N_FISCAL_YEARS_N: + case ApexParser.LAST_N_FISCAL_YEARS_N: + case ApexParser.N_FISCAL_YEARS_AGO_N: + case ApexParser.IntegralCurrencyLiteral: + case ApexParser.FIND: + case ApexParser.EMAIL: + case ApexParser.NAME: + case ApexParser.PHONE: + case ApexParser.SIDEBAR: + case ApexParser.FIELDS: + case ApexParser.METADATA: + case ApexParser.PRICEBOOKID: + case ApexParser.NETWORK: + case ApexParser.SNIPPET: + case ApexParser.TARGET_LENGTH: + case ApexParser.DIVISION: + case ApexParser.RETURNING: + case ApexParser.LISTVIEW: + case ApexParser.FindLiteral: + case ApexParser.IntegerLiteral: + case ApexParser.LongLiteral: + case ApexParser.NumberLiteral: + case ApexParser.BooleanLiteral: + case ApexParser.StringLiteral: + case ApexParser.LPAREN: + case ApexParser.LBRACE: + case ApexParser.LBRACK: + case ApexParser.BANG: + case ApexParser.TILDE: + case ApexParser.INC: + case ApexParser.DEC: + case ApexParser.ADD: + case ApexParser.SUB: + case ApexParser.ATSIGN: + case ApexParser.Identifier: + { + this.state = 731; + this.statement(); + } + break; + case ApexParser.SEMI: + { + this.state = 732; + this.match(ApexParser.SEMI); + } + break; + default: + throw new antlr.NoViableAltException(this); + } + } + } + catch (re) { + if (re instanceof antlr.RecognitionException) { + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return localContext; + } + public whileStatement(): WhileStatementContext { + const localContext = new WhileStatementContext(this.context, this.state); + this.enterRule(localContext, 92, ApexParser.RULE_whileStatement); + try { + this.enterOuterAlt(localContext, 1); + { + this.state = 735; + this.match(ApexParser.WHILE); + this.state = 736; + this.parExpression(); + this.state = 739; + this.errorHandler.sync(this); + switch (this.tokenStream.LA(1)) { + case ApexParser.ABSTRACT: + case ApexParser.AFTER: + case ApexParser.BEFORE: + case ApexParser.BREAK: + case ApexParser.CONTINUE: + case ApexParser.DELETE: + case ApexParser.DO: + case ApexParser.FINAL: + case ApexParser.FOR: + case ApexParser.GET: + case ApexParser.GLOBAL: + case ApexParser.IF: + case ApexParser.INHERITED: + case ApexParser.INSERT: + case ApexParser.INSTANCEOF: + case ApexParser.MERGE: + case ApexParser.NEW: + case ApexParser.NULL: + case ApexParser.OVERRIDE: + case ApexParser.PRIVATE: + case ApexParser.PROTECTED: + case ApexParser.PUBLIC: + case ApexParser.RETURN: + case ApexParser.SYSTEMRUNAS: + case ApexParser.SET: + case ApexParser.SHARING: + case ApexParser.STATIC: + case ApexParser.SUPER: + case ApexParser.SWITCH: + case ApexParser.TESTMETHOD: + case ApexParser.THIS: + case ApexParser.THROW: + case ApexParser.TRANSIENT: + case ApexParser.TRIGGER: + case ApexParser.TRY: + case ApexParser.UNDELETE: + case ApexParser.UPDATE: + case ApexParser.UPSERT: + case ApexParser.VIRTUAL: + case ApexParser.VOID: + case ApexParser.WEBSERVICE: + case ApexParser.WHEN: + case ApexParser.WHILE: + case ApexParser.WITH: + case ApexParser.WITHOUT: + case ApexParser.LIST: + case ApexParser.MAP: + case ApexParser.SYSTEM: + case ApexParser.USER: + case ApexParser.SELECT: + case ApexParser.COUNT: + case ApexParser.FROM: + case ApexParser.AS: + case ApexParser.USING: + case ApexParser.SCOPE: + case ApexParser.WHERE: + case ApexParser.ORDER: + case ApexParser.BY: + case ApexParser.LIMIT: + case ApexParser.SOQLAND: + case ApexParser.SOQLOR: + case ApexParser.NOT: + case ApexParser.AVG: + case ApexParser.COUNT_DISTINCT: + case ApexParser.MIN: + case ApexParser.MAX: + case ApexParser.SUM: + case ApexParser.TYPEOF: + case ApexParser.END: + case ApexParser.THEN: + case ApexParser.LIKE: + case ApexParser.IN: + case ApexParser.INCLUDES: + case ApexParser.EXCLUDES: + case ApexParser.ASC: + case ApexParser.DESC: + case ApexParser.NULLS: + case ApexParser.FIRST: + case ApexParser.LAST: + case ApexParser.GROUP: + case ApexParser.ALL: + case ApexParser.ROWS: + case ApexParser.VIEW: + case ApexParser.HAVING: + case ApexParser.ROLLUP: + case ApexParser.TOLABEL: + case ApexParser.OFFSET: + case ApexParser.DATA: + case ApexParser.CATEGORY: + case ApexParser.AT: + case ApexParser.ABOVE: + case ApexParser.BELOW: + case ApexParser.ABOVE_OR_BELOW: + case ApexParser.SECURITY_ENFORCED: + case ApexParser.SYSTEM_MODE: + case ApexParser.USER_MODE: + case ApexParser.REFERENCE: + case ApexParser.CUBE: + case ApexParser.FORMAT: + case ApexParser.TRACKING: + case ApexParser.VIEWSTAT: + case ApexParser.CUSTOM: + case ApexParser.STANDARD: + case ApexParser.DISTANCE: + case ApexParser.GEOLOCATION: + case ApexParser.CALENDAR_MONTH: + case ApexParser.CALENDAR_QUARTER: + case ApexParser.CALENDAR_YEAR: + case ApexParser.DAY_IN_MONTH: + case ApexParser.DAY_IN_WEEK: + case ApexParser.DAY_IN_YEAR: + case ApexParser.DAY_ONLY: + case ApexParser.FISCAL_MONTH: + case ApexParser.FISCAL_QUARTER: + case ApexParser.FISCAL_YEAR: + case ApexParser.HOUR_IN_DAY: + case ApexParser.WEEK_IN_MONTH: + case ApexParser.WEEK_IN_YEAR: + case ApexParser.CONVERT_TIMEZONE: + case ApexParser.YESTERDAY: + case ApexParser.TODAY: + case ApexParser.TOMORROW: + case ApexParser.LAST_WEEK: + case ApexParser.THIS_WEEK: + case ApexParser.NEXT_WEEK: + case ApexParser.LAST_MONTH: + case ApexParser.THIS_MONTH: + case ApexParser.NEXT_MONTH: + case ApexParser.LAST_90_DAYS: + case ApexParser.NEXT_90_DAYS: + case ApexParser.LAST_N_DAYS_N: + case ApexParser.NEXT_N_DAYS_N: + case ApexParser.N_DAYS_AGO_N: + case ApexParser.NEXT_N_WEEKS_N: + case ApexParser.LAST_N_WEEKS_N: + case ApexParser.N_WEEKS_AGO_N: + case ApexParser.NEXT_N_MONTHS_N: + case ApexParser.LAST_N_MONTHS_N: + case ApexParser.N_MONTHS_AGO_N: + case ApexParser.THIS_QUARTER: + case ApexParser.LAST_QUARTER: + case ApexParser.NEXT_QUARTER: + case ApexParser.NEXT_N_QUARTERS_N: + case ApexParser.LAST_N_QUARTERS_N: + case ApexParser.N_QUARTERS_AGO_N: + case ApexParser.THIS_YEAR: + case ApexParser.LAST_YEAR: + case ApexParser.NEXT_YEAR: + case ApexParser.NEXT_N_YEARS_N: + case ApexParser.LAST_N_YEARS_N: + case ApexParser.N_YEARS_AGO_N: + case ApexParser.THIS_FISCAL_QUARTER: + case ApexParser.LAST_FISCAL_QUARTER: + case ApexParser.NEXT_FISCAL_QUARTER: + case ApexParser.NEXT_N_FISCAL_QUARTERS_N: + case ApexParser.LAST_N_FISCAL_QUARTERS_N: + case ApexParser.N_FISCAL_QUARTERS_AGO_N: + case ApexParser.THIS_FISCAL_YEAR: + case ApexParser.LAST_FISCAL_YEAR: + case ApexParser.NEXT_FISCAL_YEAR: + case ApexParser.NEXT_N_FISCAL_YEARS_N: + case ApexParser.LAST_N_FISCAL_YEARS_N: + case ApexParser.N_FISCAL_YEARS_AGO_N: + case ApexParser.IntegralCurrencyLiteral: + case ApexParser.FIND: + case ApexParser.EMAIL: + case ApexParser.NAME: + case ApexParser.PHONE: + case ApexParser.SIDEBAR: + case ApexParser.FIELDS: + case ApexParser.METADATA: + case ApexParser.PRICEBOOKID: + case ApexParser.NETWORK: + case ApexParser.SNIPPET: + case ApexParser.TARGET_LENGTH: + case ApexParser.DIVISION: + case ApexParser.RETURNING: + case ApexParser.LISTVIEW: + case ApexParser.FindLiteral: + case ApexParser.IntegerLiteral: + case ApexParser.LongLiteral: + case ApexParser.NumberLiteral: + case ApexParser.BooleanLiteral: + case ApexParser.StringLiteral: + case ApexParser.LPAREN: + case ApexParser.LBRACE: + case ApexParser.LBRACK: + case ApexParser.BANG: + case ApexParser.TILDE: + case ApexParser.INC: + case ApexParser.DEC: + case ApexParser.ADD: + case ApexParser.SUB: + case ApexParser.ATSIGN: + case ApexParser.Identifier: + { + this.state = 737; + this.statement(); + } + break; + case ApexParser.SEMI: + { + this.state = 738; + this.match(ApexParser.SEMI); + } + break; + default: + throw new antlr.NoViableAltException(this); + } + } + } + catch (re) { + if (re instanceof antlr.RecognitionException) { + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return localContext; + } + public doWhileStatement(): DoWhileStatementContext { + const localContext = new DoWhileStatementContext(this.context, this.state); + this.enterRule(localContext, 94, ApexParser.RULE_doWhileStatement); + try { + this.enterOuterAlt(localContext, 1); + { + this.state = 741; + this.match(ApexParser.DO); + this.state = 742; + this.statement(); + this.state = 743; + this.match(ApexParser.WHILE); + this.state = 744; + this.parExpression(); + this.state = 745; + this.match(ApexParser.SEMI); + } + } + catch (re) { + if (re instanceof antlr.RecognitionException) { + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return localContext; + } + public tryStatement(): TryStatementContext { + const localContext = new TryStatementContext(this.context, this.state); + this.enterRule(localContext, 96, ApexParser.RULE_tryStatement); + let _la: number; + try { + this.enterOuterAlt(localContext, 1); + { + this.state = 747; + this.match(ApexParser.TRY); + this.state = 748; + this.block(); + this.state = 758; + this.errorHandler.sync(this); + switch (this.tokenStream.LA(1)) { + case ApexParser.CATCH: + { + this.state = 750; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + do { + { + { + this.state = 749; + this.catchClause(); + } + } + this.state = 752; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + } while (_la === 5); + this.state = 755; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 14) { + { + this.state = 754; + this.finallyBlock(); + } + } + + } + break; + case ApexParser.FINALLY: + { + this.state = 757; + this.finallyBlock(); + } + break; + default: + throw new antlr.NoViableAltException(this); + } + } + } + catch (re) { + if (re instanceof antlr.RecognitionException) { + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return localContext; + } + public returnStatement(): ReturnStatementContext { + const localContext = new ReturnStatementContext(this.context, this.state); + this.enterRule(localContext, 98, ApexParser.RULE_returnStatement); + let _la: number; + try { + this.enterOuterAlt(localContext, 1); + { + this.state = 760; + this.match(ApexParser.RETURN); + this.state = 762; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if ((((_la) & ~0x1F) === 0 && ((1 << _la) & 105971724) !== 0) || ((((_la - 34)) & ~0x1F) === 0 && ((1 << (_la - 34)) & 4294607707) !== 0) || ((((_la - 66)) & ~0x1F) === 0 && ((1 << (_la - 66)) & 4294967295) !== 0) || ((((_la - 98)) & ~0x1F) === 0 && ((1 << (_la - 98)) & 4294967295) !== 0) || ((((_la - 130)) & ~0x1F) === 0 && ((1 << (_la - 130)) & 4294967295) !== 0) || ((((_la - 162)) & ~0x1F) === 0 && ((1 << (_la - 162)) & 3758090239) !== 0) || ((((_la - 194)) & ~0x1F) === 0 && ((1 << (_la - 194)) & 3758293271) !== 0) || _la === 226 || _la === 244) { + { + this.state = 761; + this.expression(0); + } + } + + this.state = 764; + this.match(ApexParser.SEMI); + } + } + catch (re) { + if (re instanceof antlr.RecognitionException) { + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return localContext; + } + public throwStatement(): ThrowStatementContext { + const localContext = new ThrowStatementContext(this.context, this.state); + this.enterRule(localContext, 100, ApexParser.RULE_throwStatement); + try { + this.enterOuterAlt(localContext, 1); + { + this.state = 766; + this.match(ApexParser.THROW); + this.state = 767; + this.expression(0); + this.state = 768; + this.match(ApexParser.SEMI); + } + } + catch (re) { + if (re instanceof antlr.RecognitionException) { + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return localContext; + } + public breakStatement(): BreakStatementContext { + const localContext = new BreakStatementContext(this.context, this.state); + this.enterRule(localContext, 102, ApexParser.RULE_breakStatement); + try { + this.enterOuterAlt(localContext, 1); + { + this.state = 770; + this.match(ApexParser.BREAK); + this.state = 771; + this.match(ApexParser.SEMI); + } + } + catch (re) { + if (re instanceof antlr.RecognitionException) { + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return localContext; + } + public continueStatement(): ContinueStatementContext { + const localContext = new ContinueStatementContext(this.context, this.state); + this.enterRule(localContext, 104, ApexParser.RULE_continueStatement); + try { + this.enterOuterAlt(localContext, 1); + { + this.state = 773; + this.match(ApexParser.CONTINUE); + this.state = 774; + this.match(ApexParser.SEMI); + } + } + catch (re) { + if (re instanceof antlr.RecognitionException) { + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return localContext; + } + public accessLevel(): AccessLevelContext { + const localContext = new AccessLevelContext(this.context, this.state); + this.enterRule(localContext, 106, ApexParser.RULE_accessLevel); + let _la: number; + try { + this.enterOuterAlt(localContext, 1); + { + this.state = 776; + this.match(ApexParser.AS); + this.state = 777; + _la = this.tokenStream.LA(1); + if(!(_la === 57 || _la === 58)) { + this.errorHandler.recoverInline(this); + } + else { + this.errorHandler.reportMatch(this); + this.consume(); + } + } + } + catch (re) { + if (re instanceof antlr.RecognitionException) { + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return localContext; + } + public insertStatement(): InsertStatementContext { + const localContext = new InsertStatementContext(this.context, this.state); + this.enterRule(localContext, 108, ApexParser.RULE_insertStatement); + try { + this.enterOuterAlt(localContext, 1); + { + this.state = 779; + this.match(ApexParser.INSERT); + this.state = 781; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 63, this.context) ) { + case 1: + { + this.state = 780; + this.accessLevel(); + } + break; + } + this.state = 783; + this.expression(0); + this.state = 784; + this.match(ApexParser.SEMI); + } + } + catch (re) { + if (re instanceof antlr.RecognitionException) { + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return localContext; + } + public updateStatement(): UpdateStatementContext { + const localContext = new UpdateStatementContext(this.context, this.state); + this.enterRule(localContext, 110, ApexParser.RULE_updateStatement); + try { + this.enterOuterAlt(localContext, 1); + { + this.state = 786; + this.match(ApexParser.UPDATE); + this.state = 788; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 64, this.context) ) { + case 1: + { + this.state = 787; + this.accessLevel(); + } + break; + } + this.state = 790; + this.expression(0); + this.state = 791; + this.match(ApexParser.SEMI); + } + } + catch (re) { + if (re instanceof antlr.RecognitionException) { + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return localContext; + } + public deleteStatement(): DeleteStatementContext { + const localContext = new DeleteStatementContext(this.context, this.state); + this.enterRule(localContext, 112, ApexParser.RULE_deleteStatement); + try { + this.enterOuterAlt(localContext, 1); + { + this.state = 793; + this.match(ApexParser.DELETE); + this.state = 795; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 65, this.context) ) { + case 1: + { + this.state = 794; + this.accessLevel(); + } + break; + } + this.state = 797; + this.expression(0); + this.state = 798; + this.match(ApexParser.SEMI); + } + } + catch (re) { + if (re instanceof antlr.RecognitionException) { + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return localContext; + } + public undeleteStatement(): UndeleteStatementContext { + const localContext = new UndeleteStatementContext(this.context, this.state); + this.enterRule(localContext, 114, ApexParser.RULE_undeleteStatement); + try { + this.enterOuterAlt(localContext, 1); + { + this.state = 800; + this.match(ApexParser.UNDELETE); + this.state = 802; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 66, this.context) ) { + case 1: + { + this.state = 801; + this.accessLevel(); + } + break; + } + this.state = 804; + this.expression(0); + this.state = 805; + this.match(ApexParser.SEMI); + } + } + catch (re) { + if (re instanceof antlr.RecognitionException) { + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return localContext; + } + public upsertStatement(): UpsertStatementContext { + const localContext = new UpsertStatementContext(this.context, this.state); + this.enterRule(localContext, 116, ApexParser.RULE_upsertStatement); + let _la: number; + try { + this.enterOuterAlt(localContext, 1); + { + this.state = 807; + this.match(ApexParser.UPSERT); + this.state = 809; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 67, this.context) ) { + case 1: + { + this.state = 808; + this.accessLevel(); + } + break; + } + this.state = 811; + this.expression(0); + this.state = 813; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if ((((_la) & ~0x1F) === 0 && ((1 << _la) & 5308428) !== 0) || ((((_la - 34)) & ~0x1F) === 0 && ((1 << (_la - 34)) & 4288283411) !== 0) || ((((_la - 66)) & ~0x1F) === 0 && ((1 << (_la - 66)) & 4294967295) !== 0) || ((((_la - 98)) & ~0x1F) === 0 && ((1 << (_la - 98)) & 4294967295) !== 0) || ((((_la - 130)) & ~0x1F) === 0 && ((1 << (_la - 130)) & 4294967295) !== 0) || ((((_la - 162)) & ~0x1F) === 0 && ((1 << (_la - 162)) & 268429311) !== 0) || _la === 244) { + { + this.state = 812; + this.qualifiedName(); + } + } + + this.state = 815; + this.match(ApexParser.SEMI); + } + } + catch (re) { + if (re instanceof antlr.RecognitionException) { + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return localContext; + } + public mergeStatement(): MergeStatementContext { + const localContext = new MergeStatementContext(this.context, this.state); + this.enterRule(localContext, 118, ApexParser.RULE_mergeStatement); + try { + this.enterOuterAlt(localContext, 1); + { + this.state = 817; + this.match(ApexParser.MERGE); + this.state = 819; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 69, this.context) ) { + case 1: + { + this.state = 818; + this.accessLevel(); + } + break; + } + this.state = 821; + this.expression(0); + this.state = 822; + this.expression(0); + this.state = 823; + this.match(ApexParser.SEMI); + } + } + catch (re) { + if (re instanceof antlr.RecognitionException) { + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return localContext; + } + public runAsStatement(): RunAsStatementContext { + const localContext = new RunAsStatementContext(this.context, this.state); + this.enterRule(localContext, 120, ApexParser.RULE_runAsStatement); + let _la: number; + try { + this.enterOuterAlt(localContext, 1); + { + this.state = 825; + this.match(ApexParser.SYSTEMRUNAS); + this.state = 826; + this.match(ApexParser.LPAREN); + this.state = 828; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if ((((_la) & ~0x1F) === 0 && ((1 << _la) & 105971724) !== 0) || ((((_la - 34)) & ~0x1F) === 0 && ((1 << (_la - 34)) & 4294607707) !== 0) || ((((_la - 66)) & ~0x1F) === 0 && ((1 << (_la - 66)) & 4294967295) !== 0) || ((((_la - 98)) & ~0x1F) === 0 && ((1 << (_la - 98)) & 4294967295) !== 0) || ((((_la - 130)) & ~0x1F) === 0 && ((1 << (_la - 130)) & 4294967295) !== 0) || ((((_la - 162)) & ~0x1F) === 0 && ((1 << (_la - 162)) & 3758090239) !== 0) || ((((_la - 194)) & ~0x1F) === 0 && ((1 << (_la - 194)) & 3758293271) !== 0) || _la === 226 || _la === 244) { + { + this.state = 827; + this.expressionList(); + } + } + + this.state = 830; + this.match(ApexParser.RPAREN); + this.state = 831; + this.block(); + } + } + catch (re) { + if (re instanceof antlr.RecognitionException) { + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return localContext; + } + public expressionStatement(): ExpressionStatementContext { + const localContext = new ExpressionStatementContext(this.context, this.state); + this.enterRule(localContext, 122, ApexParser.RULE_expressionStatement); + try { + this.enterOuterAlt(localContext, 1); + { + this.state = 833; + this.expression(0); + this.state = 834; + this.match(ApexParser.SEMI); + } + } + catch (re) { + if (re instanceof antlr.RecognitionException) { + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return localContext; + } + public propertyBlock(): PropertyBlockContext { + const localContext = new PropertyBlockContext(this.context, this.state); + this.enterRule(localContext, 124, ApexParser.RULE_propertyBlock); + let _la: number; + try { + this.enterOuterAlt(localContext, 1); + { + this.state = 839; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + while ((((_la) & ~0x1F) === 0 && ((1 << _la) & 4027719682) !== 0) || ((((_la - 36)) & ~0x1F) === 0 && ((1 << (_la - 36)) & 413769) !== 0) || _la === 243) { + { + { + this.state = 836; + this.modifier(); + } + } + this.state = 841; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + } + this.state = 844; + this.errorHandler.sync(this); + switch (this.tokenStream.LA(1)) { + case ApexParser.GET: + { + this.state = 842; + this.getter(); + } + break; + case ApexParser.SET: + { + this.state = 843; + this.setter(); + } + break; + default: + throw new antlr.NoViableAltException(this); + } + } + } + catch (re) { + if (re instanceof antlr.RecognitionException) { + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return localContext; + } + public getter(): GetterContext { + const localContext = new GetterContext(this.context, this.state); + this.enterRule(localContext, 126, ApexParser.RULE_getter); + try { + this.enterOuterAlt(localContext, 1); + { + this.state = 846; + this.match(ApexParser.GET); + this.state = 849; + this.errorHandler.sync(this); + switch (this.tokenStream.LA(1)) { + case ApexParser.SEMI: + { + this.state = 847; + this.match(ApexParser.SEMI); + } + break; + case ApexParser.LBRACE: + { + this.state = 848; + this.block(); + } + break; + default: + throw new antlr.NoViableAltException(this); + } + } + } + catch (re) { + if (re instanceof antlr.RecognitionException) { + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return localContext; + } + public setter(): SetterContext { + const localContext = new SetterContext(this.context, this.state); + this.enterRule(localContext, 128, ApexParser.RULE_setter); + try { + this.enterOuterAlt(localContext, 1); + { + this.state = 851; + this.match(ApexParser.SET); + this.state = 854; + this.errorHandler.sync(this); + switch (this.tokenStream.LA(1)) { + case ApexParser.SEMI: + { + this.state = 852; + this.match(ApexParser.SEMI); + } + break; + case ApexParser.LBRACE: + { + this.state = 853; + this.block(); + } + break; + default: + throw new antlr.NoViableAltException(this); + } + } + } + catch (re) { + if (re instanceof antlr.RecognitionException) { + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return localContext; + } + public catchClause(): CatchClauseContext { + const localContext = new CatchClauseContext(this.context, this.state); + this.enterRule(localContext, 130, ApexParser.RULE_catchClause); + try { + let alternative: number; + this.enterOuterAlt(localContext, 1); + { + this.state = 856; + this.match(ApexParser.CATCH); + this.state = 857; + this.match(ApexParser.LPAREN); + this.state = 861; + this.errorHandler.sync(this); + alternative = this.interpreter.adaptivePredict(this.tokenStream, 75, this.context); + while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) { + if (alternative === 1) { + { + { + this.state = 858; + this.modifier(); + } + } + } + this.state = 863; + this.errorHandler.sync(this); + alternative = this.interpreter.adaptivePredict(this.tokenStream, 75, this.context); + } + this.state = 864; + this.qualifiedName(); + this.state = 865; + this.id(); + this.state = 866; + this.match(ApexParser.RPAREN); + this.state = 867; + this.block(); + } + } + catch (re) { + if (re instanceof antlr.RecognitionException) { + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return localContext; + } + public finallyBlock(): FinallyBlockContext { + const localContext = new FinallyBlockContext(this.context, this.state); + this.enterRule(localContext, 132, ApexParser.RULE_finallyBlock); + try { + this.enterOuterAlt(localContext, 1); + { + this.state = 869; + this.match(ApexParser.FINALLY); + this.state = 870; + this.block(); + } + } + catch (re) { + if (re instanceof antlr.RecognitionException) { + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return localContext; + } + public forControl(): ForControlContext { + const localContext = new ForControlContext(this.context, this.state); + this.enterRule(localContext, 134, ApexParser.RULE_forControl); + let _la: number; + try { + this.state = 884; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 79, this.context) ) { + case 1: + this.enterOuterAlt(localContext, 1); + { + this.state = 872; + this.enhancedForControl(); + } + break; + case 2: + this.enterOuterAlt(localContext, 2); + { + this.state = 874; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if ((((_la) & ~0x1F) === 0 && ((1 << _la) & 4132642830) !== 0) || ((((_la - 34)) & ~0x1F) === 0 && ((1 << (_la - 34)) & 4294689663) !== 0) || ((((_la - 66)) & ~0x1F) === 0 && ((1 << (_la - 66)) & 4294967295) !== 0) || ((((_la - 98)) & ~0x1F) === 0 && ((1 << (_la - 98)) & 4294967295) !== 0) || ((((_la - 130)) & ~0x1F) === 0 && ((1 << (_la - 130)) & 4294967295) !== 0) || ((((_la - 162)) & ~0x1F) === 0 && ((1 << (_la - 162)) & 3758090239) !== 0) || ((((_la - 194)) & ~0x1F) === 0 && ((1 << (_la - 194)) & 3758293271) !== 0) || ((((_la - 226)) & ~0x1F) === 0 && ((1 << (_la - 226)) & 393217) !== 0)) { + { + this.state = 873; + this.forInit(); + } + } + + this.state = 876; + this.match(ApexParser.SEMI); + this.state = 878; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if ((((_la) & ~0x1F) === 0 && ((1 << _la) & 105971724) !== 0) || ((((_la - 34)) & ~0x1F) === 0 && ((1 << (_la - 34)) & 4294607707) !== 0) || ((((_la - 66)) & ~0x1F) === 0 && ((1 << (_la - 66)) & 4294967295) !== 0) || ((((_la - 98)) & ~0x1F) === 0 && ((1 << (_la - 98)) & 4294967295) !== 0) || ((((_la - 130)) & ~0x1F) === 0 && ((1 << (_la - 130)) & 4294967295) !== 0) || ((((_la - 162)) & ~0x1F) === 0 && ((1 << (_la - 162)) & 3758090239) !== 0) || ((((_la - 194)) & ~0x1F) === 0 && ((1 << (_la - 194)) & 3758293271) !== 0) || _la === 226 || _la === 244) { + { + this.state = 877; + this.expression(0); + } + } + + this.state = 880; + this.match(ApexParser.SEMI); + this.state = 882; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if ((((_la) & ~0x1F) === 0 && ((1 << _la) & 105971724) !== 0) || ((((_la - 34)) & ~0x1F) === 0 && ((1 << (_la - 34)) & 4294607707) !== 0) || ((((_la - 66)) & ~0x1F) === 0 && ((1 << (_la - 66)) & 4294967295) !== 0) || ((((_la - 98)) & ~0x1F) === 0 && ((1 << (_la - 98)) & 4294967295) !== 0) || ((((_la - 130)) & ~0x1F) === 0 && ((1 << (_la - 130)) & 4294967295) !== 0) || ((((_la - 162)) & ~0x1F) === 0 && ((1 << (_la - 162)) & 3758090239) !== 0) || ((((_la - 194)) & ~0x1F) === 0 && ((1 << (_la - 194)) & 3758293271) !== 0) || _la === 226 || _la === 244) { + { + this.state = 881; + this.forUpdate(); + } + } + + } + break; + } + } + catch (re) { + if (re instanceof antlr.RecognitionException) { + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return localContext; + } + public forInit(): ForInitContext { + const localContext = new ForInitContext(this.context, this.state); + this.enterRule(localContext, 136, ApexParser.RULE_forInit); + try { + this.state = 888; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 80, this.context) ) { + case 1: + this.enterOuterAlt(localContext, 1); + { + this.state = 886; + this.localVariableDeclaration(); + } + break; + case 2: + this.enterOuterAlt(localContext, 2); + { + this.state = 887; + this.expressionList(); + } + break; + } + } + catch (re) { + if (re instanceof antlr.RecognitionException) { + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return localContext; + } + public enhancedForControl(): EnhancedForControlContext { + const localContext = new EnhancedForControlContext(this.context, this.state); + this.enterRule(localContext, 138, ApexParser.RULE_enhancedForControl); + try { + this.enterOuterAlt(localContext, 1); + { + this.state = 890; + this.typeRef(); + this.state = 891; + this.id(); + this.state = 892; + this.match(ApexParser.COLON); + this.state = 893; + this.expression(0); + } + } + catch (re) { + if (re instanceof antlr.RecognitionException) { + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return localContext; + } + public forUpdate(): ForUpdateContext { + const localContext = new ForUpdateContext(this.context, this.state); + this.enterRule(localContext, 140, ApexParser.RULE_forUpdate); + try { + this.enterOuterAlt(localContext, 1); + { + this.state = 895; + this.expressionList(); + } + } + catch (re) { + if (re instanceof antlr.RecognitionException) { + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return localContext; + } + public parExpression(): ParExpressionContext { + const localContext = new ParExpressionContext(this.context, this.state); + this.enterRule(localContext, 142, ApexParser.RULE_parExpression); + try { + this.enterOuterAlt(localContext, 1); + { + this.state = 897; + this.match(ApexParser.LPAREN); + this.state = 898; + this.expression(0); + this.state = 899; + this.match(ApexParser.RPAREN); + } + } + catch (re) { + if (re instanceof antlr.RecognitionException) { + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return localContext; + } + public expressionList(): ExpressionListContext { + const localContext = new ExpressionListContext(this.context, this.state); + this.enterRule(localContext, 144, ApexParser.RULE_expressionList); + let _la: number; + try { + this.enterOuterAlt(localContext, 1); + { + this.state = 901; + this.expression(0); + this.state = 906; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + while (_la === 205) { + { + { + this.state = 902; + this.match(ApexParser.COMMA); + this.state = 903; + this.expression(0); + } + } + this.state = 908; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + } + } + } + catch (re) { + if (re instanceof antlr.RecognitionException) { + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return localContext; + } + + public expression(): ExpressionContext; + public expression(_p: number): ExpressionContext; + public expression(_p?: number): ExpressionContext { + if (_p === undefined) { + _p = 0; + } + + const parentContext = this.context; + const parentState = this.state; + let localContext = new ExpressionContext(this.context, parentState); + let previousContext = localContext; + const _startState = 146; + this.enterRecursionRule(localContext, 146, ApexParser.RULE_expression, _p); + let _la: number; + try { + let alternative: number; + this.enterOuterAlt(localContext, 1); + { + this.state = 927; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 82, this.context) ) { + case 1: + { + localContext = new PrimaryExpressionContext(localContext); + this.context = localContext; + previousContext = localContext; + + this.state = 910; + this.primary(); + } + break; + case 2: + { + localContext = new MethodCallExpressionContext(localContext); + this.context = localContext; + previousContext = localContext; + this.state = 911; + this.methodCall(); + } + break; + case 3: + { + localContext = new NewExpressionContext(localContext); + this.context = localContext; + previousContext = localContext; + this.state = 912; + this.match(ApexParser.NEW); + this.state = 913; + this.creator(); + } + break; + case 4: + { + localContext = new CastExpressionContext(localContext); + this.context = localContext; + previousContext = localContext; + this.state = 914; + this.match(ApexParser.LPAREN); + this.state = 915; + this.typeRef(); + this.state = 916; + this.match(ApexParser.RPAREN); + this.state = 917; + this.expression(19); + } + break; + case 5: + { + localContext = new SubExpressionContext(localContext); + this.context = localContext; + previousContext = localContext; + this.state = 919; + this.match(ApexParser.LPAREN); + this.state = 920; + this.expression(0); + this.state = 921; + this.match(ApexParser.RPAREN); + } + break; + case 6: + { + localContext = new PreOpExpressionContext(localContext); + this.context = localContext; + previousContext = localContext; + this.state = 923; + _la = this.tokenStream.LA(1); + if(!(((((_la - 223)) & ~0x1F) === 0 && ((1 << (_la - 223)) & 15) !== 0))) { + this.errorHandler.recoverInline(this); + } + else { + this.errorHandler.reportMatch(this); + this.consume(); + } + this.state = 924; + this.expression(16); + } + break; + case 7: + { + localContext = new NegExpressionContext(localContext); + this.context = localContext; + previousContext = localContext; + this.state = 925; + _la = this.tokenStream.LA(1); + if(!(_la === 210 || _la === 211)) { + this.errorHandler.recoverInline(this); + } + else { + this.errorHandler.reportMatch(this); + this.consume(); + } + this.state = 926; + this.expression(15); + } + break; + } + this.context!.stop = this.tokenStream.LT(-1); + this.state = 1000; + this.errorHandler.sync(this); + alternative = this.interpreter.adaptivePredict(this.tokenStream, 87, this.context); + while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) { + if (alternative === 1) { + if (this.parseListeners != null) { + this.triggerExitRuleEvent(); + } + previousContext = localContext; + { + this.state = 998; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 86, this.context) ) { + case 1: + { + localContext = new Arth1ExpressionContext(new ExpressionContext(parentContext, parentState)); + this.pushNewRecursionContext(localContext, _startState, ApexParser.RULE_expression); + this.state = 929; + if (!(this.precpred(this.context, 14))) { + throw this.createFailedPredicateException("this.precpred(this.context, 14)"); + } + this.state = 930; + _la = this.tokenStream.LA(1); + if(!(_la === 227 || _la === 228)) { + this.errorHandler.recoverInline(this); + } + else { + this.errorHandler.reportMatch(this); + this.consume(); + } + this.state = 931; + this.expression(15); + } + break; + case 2: + { + localContext = new Arth2ExpressionContext(new ExpressionContext(parentContext, parentState)); + this.pushNewRecursionContext(localContext, _startState, ApexParser.RULE_expression); + this.state = 932; + if (!(this.precpred(this.context, 13))) { + throw this.createFailedPredicateException("this.precpred(this.context, 13)"); + } + this.state = 933; + _la = this.tokenStream.LA(1); + if(!(_la === 225 || _la === 226)) { + this.errorHandler.recoverInline(this); + } + else { + this.errorHandler.reportMatch(this); + this.consume(); + } + this.state = 934; + this.expression(14); + } + break; + case 3: + { + localContext = new BitExpressionContext(new ExpressionContext(parentContext, parentState)); + this.pushNewRecursionContext(localContext, _startState, ApexParser.RULE_expression); + this.state = 935; + if (!(this.precpred(this.context, 12))) { + throw this.createFailedPredicateException("this.precpred(this.context, 12)"); + } + this.state = 943; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 83, this.context) ) { + case 1: + { + this.state = 936; + this.match(ApexParser.LT); + this.state = 937; + this.match(ApexParser.LT); + } + break; + case 2: + { + this.state = 938; + this.match(ApexParser.GT); + this.state = 939; + this.match(ApexParser.GT); + this.state = 940; + this.match(ApexParser.GT); + } + break; + case 3: + { + this.state = 941; + this.match(ApexParser.GT); + this.state = 942; + this.match(ApexParser.GT); + } + break; + } + this.state = 945; + this.expression(13); + } + break; + case 4: + { + localContext = new CmpExpressionContext(new ExpressionContext(parentContext, parentState)); + this.pushNewRecursionContext(localContext, _startState, ApexParser.RULE_expression); + this.state = 946; + if (!(this.precpred(this.context, 11))) { + throw this.createFailedPredicateException("this.precpred(this.context, 11)"); + } + this.state = 947; + _la = this.tokenStream.LA(1); + if(!(_la === 208 || _la === 209)) { + this.errorHandler.recoverInline(this); + } + else { + this.errorHandler.reportMatch(this); + this.consume(); + } + this.state = 949; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 207) { + { + this.state = 948; + this.match(ApexParser.ASSIGN); + } + } + + this.state = 951; + this.expression(12); + } + break; + case 5: + { + localContext = new EqualityExpressionContext(new ExpressionContext(parentContext, parentState)); + this.pushNewRecursionContext(localContext, _startState, ApexParser.RULE_expression); + this.state = 952; + if (!(this.precpred(this.context, 9))) { + throw this.createFailedPredicateException("this.precpred(this.context, 9)"); + } + this.state = 953; + _la = this.tokenStream.LA(1); + if(!(((((_la - 216)) & ~0x1F) === 0 && ((1 << (_la - 216)) & 31) !== 0))) { + this.errorHandler.recoverInline(this); + } + else { + this.errorHandler.reportMatch(this); + this.consume(); + } + this.state = 954; + this.expression(10); + } + break; + case 6: + { + localContext = new BitAndExpressionContext(new ExpressionContext(parentContext, parentState)); + this.pushNewRecursionContext(localContext, _startState, ApexParser.RULE_expression); + this.state = 955; + if (!(this.precpred(this.context, 8))) { + throw this.createFailedPredicateException("this.precpred(this.context, 8)"); + } + this.state = 956; + this.match(ApexParser.BITAND); + this.state = 957; + this.expression(9); + } + break; + case 7: + { + localContext = new BitNotExpressionContext(new ExpressionContext(parentContext, parentState)); + this.pushNewRecursionContext(localContext, _startState, ApexParser.RULE_expression); + this.state = 958; + if (!(this.precpred(this.context, 7))) { + throw this.createFailedPredicateException("this.precpred(this.context, 7)"); + } + this.state = 959; + this.match(ApexParser.CARET); + this.state = 960; + this.expression(8); + } + break; + case 8: + { + localContext = new BitOrExpressionContext(new ExpressionContext(parentContext, parentState)); + this.pushNewRecursionContext(localContext, _startState, ApexParser.RULE_expression); + this.state = 961; + if (!(this.precpred(this.context, 6))) { + throw this.createFailedPredicateException("this.precpred(this.context, 6)"); + } + this.state = 962; + this.match(ApexParser.BITOR); + this.state = 963; + this.expression(7); + } + break; + case 9: + { + localContext = new LogAndExpressionContext(new ExpressionContext(parentContext, parentState)); + this.pushNewRecursionContext(localContext, _startState, ApexParser.RULE_expression); + this.state = 964; + if (!(this.precpred(this.context, 5))) { + throw this.createFailedPredicateException("this.precpred(this.context, 5)"); + } + this.state = 965; + this.match(ApexParser.AND); + this.state = 966; + this.expression(6); + } + break; + case 10: + { + localContext = new LogOrExpressionContext(new ExpressionContext(parentContext, parentState)); + this.pushNewRecursionContext(localContext, _startState, ApexParser.RULE_expression); + this.state = 967; + if (!(this.precpred(this.context, 4))) { + throw this.createFailedPredicateException("this.precpred(this.context, 4)"); + } + this.state = 968; + this.match(ApexParser.OR); + this.state = 969; + this.expression(5); + } + break; + case 11: + { + localContext = new CondExpressionContext(new ExpressionContext(parentContext, parentState)); + this.pushNewRecursionContext(localContext, _startState, ApexParser.RULE_expression); + this.state = 970; + if (!(this.precpred(this.context, 3))) { + throw this.createFailedPredicateException("this.precpred(this.context, 3)"); + } + this.state = 971; + this.match(ApexParser.QUESTION); + this.state = 972; + this.expression(0); + this.state = 973; + this.match(ApexParser.COLON); + this.state = 974; + this.expression(3); + } + break; + case 12: + { + localContext = new CoalescingExpressionContext(new ExpressionContext(parentContext, parentState)); + this.pushNewRecursionContext(localContext, _startState, ApexParser.RULE_expression); + this.state = 976; + if (!(this.precpred(this.context, 2))) { + throw this.createFailedPredicateException("this.precpred(this.context, 2)"); + } + this.state = 977; + this.match(ApexParser.DOUBLEQUESTION); + this.state = 978; + this.expression(2); + } + break; + case 13: + { + localContext = new AssignExpressionContext(new ExpressionContext(parentContext, parentState)); + this.pushNewRecursionContext(localContext, _startState, ApexParser.RULE_expression); + this.state = 979; + if (!(this.precpred(this.context, 1))) { + throw this.createFailedPredicateException("this.precpred(this.context, 1)"); + } + this.state = 980; + _la = this.tokenStream.LA(1); + if(!(((((_la - 207)) & ~0x1F) === 0 && ((1 << (_la - 207)) & 4227858433) !== 0) || ((((_la - 239)) & ~0x1F) === 0 && ((1 << (_la - 239)) & 15) !== 0))) { + this.errorHandler.recoverInline(this); + } + else { + this.errorHandler.reportMatch(this); + this.consume(); + } + this.state = 981; + this.expression(1); + } + break; + case 14: + { + localContext = new DotExpressionContext(new ExpressionContext(parentContext, parentState)); + this.pushNewRecursionContext(localContext, _startState, ApexParser.RULE_expression); + this.state = 982; + if (!(this.precpred(this.context, 23))) { + throw this.createFailedPredicateException("this.precpred(this.context, 23)"); + } + this.state = 983; + _la = this.tokenStream.LA(1); + if(!(_la === 206 || _la === 212)) { + this.errorHandler.recoverInline(this); + } + else { + this.errorHandler.reportMatch(this); + this.consume(); + } + this.state = 986; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 85, this.context) ) { + case 1: + { + this.state = 984; + this.dotMethodCall(); + } + break; + case 2: + { + this.state = 985; + this.anyId(); + } + break; + } + } + break; + case 15: + { + localContext = new ArrayExpressionContext(new ExpressionContext(parentContext, parentState)); + this.pushNewRecursionContext(localContext, _startState, ApexParser.RULE_expression); + this.state = 988; + if (!(this.precpred(this.context, 22))) { + throw this.createFailedPredicateException("this.precpred(this.context, 22)"); + } + this.state = 989; + this.match(ApexParser.LBRACK); + this.state = 990; + this.expression(0); + this.state = 991; + this.match(ApexParser.RBRACK); + } + break; + case 16: + { + localContext = new PostOpExpressionContext(new ExpressionContext(parentContext, parentState)); + this.pushNewRecursionContext(localContext, _startState, ApexParser.RULE_expression); + this.state = 993; + if (!(this.precpred(this.context, 17))) { + throw this.createFailedPredicateException("this.precpred(this.context, 17)"); + } + this.state = 994; + _la = this.tokenStream.LA(1); + if(!(_la === 223 || _la === 224)) { + this.errorHandler.recoverInline(this); + } + else { + this.errorHandler.reportMatch(this); + this.consume(); + } + } + break; + case 17: + { + localContext = new InstanceOfExpressionContext(new ExpressionContext(parentContext, parentState)); + this.pushNewRecursionContext(localContext, _startState, ApexParser.RULE_expression); + this.state = 995; + if (!(this.precpred(this.context, 10))) { + throw this.createFailedPredicateException("this.precpred(this.context, 10)"); + } + this.state = 996; + this.match(ApexParser.INSTANCEOF); + this.state = 997; + this.typeRef(); + } + break; + } + } + } + this.state = 1002; + this.errorHandler.sync(this); + alternative = this.interpreter.adaptivePredict(this.tokenStream, 87, this.context); + } + } + } + catch (re) { + if (re instanceof antlr.RecognitionException) { + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.unrollRecursionContexts(parentContext); + } + return localContext; + } + public primary(): PrimaryContext { + let localContext = new PrimaryContext(this.context, this.state); + this.enterRule(localContext, 148, ApexParser.RULE_primary); + try { + this.state = 1016; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 88, this.context) ) { + case 1: + localContext = new ThisPrimaryContext(localContext); + this.enterOuterAlt(localContext, 1); + { + this.state = 1003; + this.match(ApexParser.THIS); + } + break; + case 2: + localContext = new SuperPrimaryContext(localContext); + this.enterOuterAlt(localContext, 2); + { + this.state = 1004; + this.match(ApexParser.SUPER); + } + break; + case 3: + localContext = new LiteralPrimaryContext(localContext); + this.enterOuterAlt(localContext, 3); + { + this.state = 1005; + this.literal(); + } + break; + case 4: + localContext = new TypeRefPrimaryContext(localContext); + this.enterOuterAlt(localContext, 4); + { + this.state = 1006; + this.typeRef(); + this.state = 1007; + this.match(ApexParser.DOT); + this.state = 1008; + this.match(ApexParser.CLASS); + } + break; + case 5: + localContext = new VoidPrimaryContext(localContext); + this.enterOuterAlt(localContext, 5); + { + this.state = 1010; + this.match(ApexParser.VOID); + this.state = 1011; + this.match(ApexParser.DOT); + this.state = 1012; + this.match(ApexParser.CLASS); + } + break; + case 6: + localContext = new IdPrimaryContext(localContext); + this.enterOuterAlt(localContext, 6); + { + this.state = 1013; + this.id(); + } + break; + case 7: + localContext = new SoqlPrimaryContext(localContext); + this.enterOuterAlt(localContext, 7); + { + this.state = 1014; + this.soqlLiteral(); + } + break; + case 8: + localContext = new SoslPrimaryContext(localContext); + this.enterOuterAlt(localContext, 8); + { + this.state = 1015; + this.soslLiteral(); + } + break; + } + } + catch (re) { + if (re instanceof antlr.RecognitionException) { + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return localContext; + } + public methodCall(): MethodCallContext { + const localContext = new MethodCallContext(this.context, this.state); + this.enterRule(localContext, 150, ApexParser.RULE_methodCall); + let _la: number; + try { + this.state = 1037; + this.errorHandler.sync(this); + switch (this.tokenStream.LA(1)) { + case ApexParser.AFTER: + case ApexParser.BEFORE: + case ApexParser.GET: + case ApexParser.INHERITED: + case ApexParser.INSTANCEOF: + case ApexParser.SET: + case ApexParser.SHARING: + case ApexParser.SWITCH: + case ApexParser.TRANSIENT: + case ApexParser.TRIGGER: + case ApexParser.WHEN: + case ApexParser.WITH: + case ApexParser.WITHOUT: + case ApexParser.SYSTEM: + case ApexParser.USER: + case ApexParser.SELECT: + case ApexParser.COUNT: + case ApexParser.FROM: + case ApexParser.AS: + case ApexParser.USING: + case ApexParser.SCOPE: + case ApexParser.WHERE: + case ApexParser.ORDER: + case ApexParser.BY: + case ApexParser.LIMIT: + case ApexParser.SOQLAND: + case ApexParser.SOQLOR: + case ApexParser.NOT: + case ApexParser.AVG: + case ApexParser.COUNT_DISTINCT: + case ApexParser.MIN: + case ApexParser.MAX: + case ApexParser.SUM: + case ApexParser.TYPEOF: + case ApexParser.END: + case ApexParser.THEN: + case ApexParser.LIKE: + case ApexParser.IN: + case ApexParser.INCLUDES: + case ApexParser.EXCLUDES: + case ApexParser.ASC: + case ApexParser.DESC: + case ApexParser.NULLS: + case ApexParser.FIRST: + case ApexParser.LAST: + case ApexParser.GROUP: + case ApexParser.ALL: + case ApexParser.ROWS: + case ApexParser.VIEW: + case ApexParser.HAVING: + case ApexParser.ROLLUP: + case ApexParser.TOLABEL: + case ApexParser.OFFSET: + case ApexParser.DATA: + case ApexParser.CATEGORY: + case ApexParser.AT: + case ApexParser.ABOVE: + case ApexParser.BELOW: + case ApexParser.ABOVE_OR_BELOW: + case ApexParser.SECURITY_ENFORCED: + case ApexParser.SYSTEM_MODE: + case ApexParser.USER_MODE: + case ApexParser.REFERENCE: + case ApexParser.CUBE: + case ApexParser.FORMAT: + case ApexParser.TRACKING: + case ApexParser.VIEWSTAT: + case ApexParser.CUSTOM: + case ApexParser.STANDARD: + case ApexParser.DISTANCE: + case ApexParser.GEOLOCATION: + case ApexParser.CALENDAR_MONTH: + case ApexParser.CALENDAR_QUARTER: + case ApexParser.CALENDAR_YEAR: + case ApexParser.DAY_IN_MONTH: + case ApexParser.DAY_IN_WEEK: + case ApexParser.DAY_IN_YEAR: + case ApexParser.DAY_ONLY: + case ApexParser.FISCAL_MONTH: + case ApexParser.FISCAL_QUARTER: + case ApexParser.FISCAL_YEAR: + case ApexParser.HOUR_IN_DAY: + case ApexParser.WEEK_IN_MONTH: + case ApexParser.WEEK_IN_YEAR: + case ApexParser.CONVERT_TIMEZONE: + case ApexParser.YESTERDAY: + case ApexParser.TODAY: + case ApexParser.TOMORROW: + case ApexParser.LAST_WEEK: + case ApexParser.THIS_WEEK: + case ApexParser.NEXT_WEEK: + case ApexParser.LAST_MONTH: + case ApexParser.THIS_MONTH: + case ApexParser.NEXT_MONTH: + case ApexParser.LAST_90_DAYS: + case ApexParser.NEXT_90_DAYS: + case ApexParser.LAST_N_DAYS_N: + case ApexParser.NEXT_N_DAYS_N: + case ApexParser.N_DAYS_AGO_N: + case ApexParser.NEXT_N_WEEKS_N: + case ApexParser.LAST_N_WEEKS_N: + case ApexParser.N_WEEKS_AGO_N: + case ApexParser.NEXT_N_MONTHS_N: + case ApexParser.LAST_N_MONTHS_N: + case ApexParser.N_MONTHS_AGO_N: + case ApexParser.THIS_QUARTER: + case ApexParser.LAST_QUARTER: + case ApexParser.NEXT_QUARTER: + case ApexParser.NEXT_N_QUARTERS_N: + case ApexParser.LAST_N_QUARTERS_N: + case ApexParser.N_QUARTERS_AGO_N: + case ApexParser.THIS_YEAR: + case ApexParser.LAST_YEAR: + case ApexParser.NEXT_YEAR: + case ApexParser.NEXT_N_YEARS_N: + case ApexParser.LAST_N_YEARS_N: + case ApexParser.N_YEARS_AGO_N: + case ApexParser.THIS_FISCAL_QUARTER: + case ApexParser.LAST_FISCAL_QUARTER: + case ApexParser.NEXT_FISCAL_QUARTER: + case ApexParser.NEXT_N_FISCAL_QUARTERS_N: + case ApexParser.LAST_N_FISCAL_QUARTERS_N: + case ApexParser.N_FISCAL_QUARTERS_AGO_N: + case ApexParser.THIS_FISCAL_YEAR: + case ApexParser.LAST_FISCAL_YEAR: + case ApexParser.NEXT_FISCAL_YEAR: + case ApexParser.NEXT_N_FISCAL_YEARS_N: + case ApexParser.LAST_N_FISCAL_YEARS_N: + case ApexParser.N_FISCAL_YEARS_AGO_N: + case ApexParser.IntegralCurrencyLiteral: + case ApexParser.FIND: + case ApexParser.EMAIL: + case ApexParser.NAME: + case ApexParser.PHONE: + case ApexParser.SIDEBAR: + case ApexParser.FIELDS: + case ApexParser.METADATA: + case ApexParser.PRICEBOOKID: + case ApexParser.NETWORK: + case ApexParser.SNIPPET: + case ApexParser.TARGET_LENGTH: + case ApexParser.DIVISION: + case ApexParser.RETURNING: + case ApexParser.LISTVIEW: + case ApexParser.Identifier: + this.enterOuterAlt(localContext, 1); + { + this.state = 1018; + this.id(); + this.state = 1019; + this.match(ApexParser.LPAREN); + this.state = 1021; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if ((((_la) & ~0x1F) === 0 && ((1 << _la) & 105971724) !== 0) || ((((_la - 34)) & ~0x1F) === 0 && ((1 << (_la - 34)) & 4294607707) !== 0) || ((((_la - 66)) & ~0x1F) === 0 && ((1 << (_la - 66)) & 4294967295) !== 0) || ((((_la - 98)) & ~0x1F) === 0 && ((1 << (_la - 98)) & 4294967295) !== 0) || ((((_la - 130)) & ~0x1F) === 0 && ((1 << (_la - 130)) & 4294967295) !== 0) || ((((_la - 162)) & ~0x1F) === 0 && ((1 << (_la - 162)) & 3758090239) !== 0) || ((((_la - 194)) & ~0x1F) === 0 && ((1 << (_la - 194)) & 3758293271) !== 0) || _la === 226 || _la === 244) { + { + this.state = 1020; + this.expressionList(); + } + } + + this.state = 1023; + this.match(ApexParser.RPAREN); + } + break; + case ApexParser.THIS: + this.enterOuterAlt(localContext, 2); + { + this.state = 1025; + this.match(ApexParser.THIS); + this.state = 1026; + this.match(ApexParser.LPAREN); + this.state = 1028; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if ((((_la) & ~0x1F) === 0 && ((1 << _la) & 105971724) !== 0) || ((((_la - 34)) & ~0x1F) === 0 && ((1 << (_la - 34)) & 4294607707) !== 0) || ((((_la - 66)) & ~0x1F) === 0 && ((1 << (_la - 66)) & 4294967295) !== 0) || ((((_la - 98)) & ~0x1F) === 0 && ((1 << (_la - 98)) & 4294967295) !== 0) || ((((_la - 130)) & ~0x1F) === 0 && ((1 << (_la - 130)) & 4294967295) !== 0) || ((((_la - 162)) & ~0x1F) === 0 && ((1 << (_la - 162)) & 3758090239) !== 0) || ((((_la - 194)) & ~0x1F) === 0 && ((1 << (_la - 194)) & 3758293271) !== 0) || _la === 226 || _la === 244) { + { + this.state = 1027; + this.expressionList(); + } + } + + this.state = 1030; + this.match(ApexParser.RPAREN); + } + break; + case ApexParser.SUPER: + this.enterOuterAlt(localContext, 3); + { + this.state = 1031; + this.match(ApexParser.SUPER); + this.state = 1032; + this.match(ApexParser.LPAREN); + this.state = 1034; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if ((((_la) & ~0x1F) === 0 && ((1 << _la) & 105971724) !== 0) || ((((_la - 34)) & ~0x1F) === 0 && ((1 << (_la - 34)) & 4294607707) !== 0) || ((((_la - 66)) & ~0x1F) === 0 && ((1 << (_la - 66)) & 4294967295) !== 0) || ((((_la - 98)) & ~0x1F) === 0 && ((1 << (_la - 98)) & 4294967295) !== 0) || ((((_la - 130)) & ~0x1F) === 0 && ((1 << (_la - 130)) & 4294967295) !== 0) || ((((_la - 162)) & ~0x1F) === 0 && ((1 << (_la - 162)) & 3758090239) !== 0) || ((((_la - 194)) & ~0x1F) === 0 && ((1 << (_la - 194)) & 3758293271) !== 0) || _la === 226 || _la === 244) { + { + this.state = 1033; + this.expressionList(); + } + } + + this.state = 1036; + this.match(ApexParser.RPAREN); + } + break; + default: + throw new antlr.NoViableAltException(this); + } + } + catch (re) { + if (re instanceof antlr.RecognitionException) { + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return localContext; + } + public dotMethodCall(): DotMethodCallContext { + const localContext = new DotMethodCallContext(this.context, this.state); + this.enterRule(localContext, 152, ApexParser.RULE_dotMethodCall); + let _la: number; + try { + this.enterOuterAlt(localContext, 1); + { + this.state = 1039; + this.anyId(); + this.state = 1040; + this.match(ApexParser.LPAREN); + this.state = 1042; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if ((((_la) & ~0x1F) === 0 && ((1 << _la) & 105971724) !== 0) || ((((_la - 34)) & ~0x1F) === 0 && ((1 << (_la - 34)) & 4294607707) !== 0) || ((((_la - 66)) & ~0x1F) === 0 && ((1 << (_la - 66)) & 4294967295) !== 0) || ((((_la - 98)) & ~0x1F) === 0 && ((1 << (_la - 98)) & 4294967295) !== 0) || ((((_la - 130)) & ~0x1F) === 0 && ((1 << (_la - 130)) & 4294967295) !== 0) || ((((_la - 162)) & ~0x1F) === 0 && ((1 << (_la - 162)) & 3758090239) !== 0) || ((((_la - 194)) & ~0x1F) === 0 && ((1 << (_la - 194)) & 3758293271) !== 0) || _la === 226 || _la === 244) { + { + this.state = 1041; + this.expressionList(); + } + } + + this.state = 1044; + this.match(ApexParser.RPAREN); + } + } + catch (re) { + if (re instanceof antlr.RecognitionException) { + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return localContext; + } + public creator(): CreatorContext { + const localContext = new CreatorContext(this.context, this.state); + this.enterRule(localContext, 154, ApexParser.RULE_creator); + try { + this.enterOuterAlt(localContext, 1); + { + this.state = 1046; + this.createdName(); + this.state = 1052; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 94, this.context) ) { + case 1: + { + this.state = 1047; + this.noRest(); + } + break; + case 2: + { + this.state = 1048; + this.classCreatorRest(); + } + break; + case 3: + { + this.state = 1049; + this.arrayCreatorRest(); + } + break; + case 4: + { + this.state = 1050; + this.mapCreatorRest(); + } + break; + case 5: + { + this.state = 1051; + this.setCreatorRest(); + } + break; + } + } + } + catch (re) { + if (re instanceof antlr.RecognitionException) { + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return localContext; + } + public createdName(): CreatedNameContext { + const localContext = new CreatedNameContext(this.context, this.state); + this.enterRule(localContext, 156, ApexParser.RULE_createdName); + let _la: number; + try { + this.enterOuterAlt(localContext, 1); + { + this.state = 1054; + this.idCreatedNamePair(); + this.state = 1059; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + while (_la === 206) { + { + { + this.state = 1055; + this.match(ApexParser.DOT); + this.state = 1056; + this.idCreatedNamePair(); + } + } + this.state = 1061; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + } + } + } + catch (re) { + if (re instanceof antlr.RecognitionException) { + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return localContext; + } + public idCreatedNamePair(): IdCreatedNamePairContext { + const localContext = new IdCreatedNamePairContext(this.context, this.state); + this.enterRule(localContext, 158, ApexParser.RULE_idCreatedNamePair); + let _la: number; + try { + this.enterOuterAlt(localContext, 1); + { + this.state = 1062; + this.anyId(); + this.state = 1067; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 209) { + { + this.state = 1063; + this.match(ApexParser.LT); + this.state = 1064; + this.typeList(); + this.state = 1065; + this.match(ApexParser.GT); + } + } + + } + } + catch (re) { + if (re instanceof antlr.RecognitionException) { + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return localContext; + } + public noRest(): NoRestContext { + const localContext = new NoRestContext(this.context, this.state); + this.enterRule(localContext, 160, ApexParser.RULE_noRest); + try { + this.enterOuterAlt(localContext, 1); + { + this.state = 1069; + this.match(ApexParser.LBRACE); + this.state = 1070; + this.match(ApexParser.RBRACE); + } + } + catch (re) { + if (re instanceof antlr.RecognitionException) { + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return localContext; + } + public classCreatorRest(): ClassCreatorRestContext { + const localContext = new ClassCreatorRestContext(this.context, this.state); + this.enterRule(localContext, 162, ApexParser.RULE_classCreatorRest); + try { + this.enterOuterAlt(localContext, 1); + { + this.state = 1072; + this.arguments(); + } + } + catch (re) { + if (re instanceof antlr.RecognitionException) { + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return localContext; + } + public arrayCreatorRest(): ArrayCreatorRestContext { + const localContext = new ArrayCreatorRestContext(this.context, this.state); + this.enterRule(localContext, 164, ApexParser.RULE_arrayCreatorRest); + try { + this.state = 1083; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 98, this.context) ) { + case 1: + this.enterOuterAlt(localContext, 1); + { + this.state = 1074; + this.match(ApexParser.LBRACK); + this.state = 1075; + this.expression(0); + this.state = 1076; + this.match(ApexParser.RBRACK); + } + break; + case 2: + this.enterOuterAlt(localContext, 2); + { + this.state = 1078; + this.match(ApexParser.LBRACK); + this.state = 1079; + this.match(ApexParser.RBRACK); + this.state = 1081; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 97, this.context) ) { + case 1: + { + this.state = 1080; + this.arrayInitializer(); + } + break; + } + } + break; + } + } + catch (re) { + if (re instanceof antlr.RecognitionException) { + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return localContext; + } + public mapCreatorRest(): MapCreatorRestContext { + const localContext = new MapCreatorRestContext(this.context, this.state); + this.enterRule(localContext, 166, ApexParser.RULE_mapCreatorRest); + let _la: number; + try { + this.enterOuterAlt(localContext, 1); + { + this.state = 1085; + this.match(ApexParser.LBRACE); + this.state = 1086; + this.mapCreatorRestPair(); + this.state = 1091; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + while (_la === 205) { + { + { + this.state = 1087; + this.match(ApexParser.COMMA); + this.state = 1088; + this.mapCreatorRestPair(); + } + } + this.state = 1093; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + } + this.state = 1094; + this.match(ApexParser.RBRACE); + } + } + catch (re) { + if (re instanceof antlr.RecognitionException) { + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return localContext; + } + public mapCreatorRestPair(): MapCreatorRestPairContext { + const localContext = new MapCreatorRestPairContext(this.context, this.state); + this.enterRule(localContext, 168, ApexParser.RULE_mapCreatorRestPair); + try { + this.enterOuterAlt(localContext, 1); + { + this.state = 1096; + this.expression(0); + this.state = 1097; + this.match(ApexParser.MAPTO); + this.state = 1098; + this.expression(0); + } + } + catch (re) { + if (re instanceof antlr.RecognitionException) { + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return localContext; + } + public setCreatorRest(): SetCreatorRestContext { + const localContext = new SetCreatorRestContext(this.context, this.state); + this.enterRule(localContext, 170, ApexParser.RULE_setCreatorRest); + let _la: number; + try { + this.enterOuterAlt(localContext, 1); + { + this.state = 1100; + this.match(ApexParser.LBRACE); + this.state = 1101; + this.expression(0); + this.state = 1106; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + while (_la === 205) { + { + { + this.state = 1102; + this.match(ApexParser.COMMA); + { + this.state = 1103; + this.expression(0); + } + } + } + this.state = 1108; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + } + this.state = 1109; + this.match(ApexParser.RBRACE); + } + } + catch (re) { + if (re instanceof antlr.RecognitionException) { + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return localContext; + } + public arguments(): ArgumentsContext { + const localContext = new ArgumentsContext(this.context, this.state); + this.enterRule(localContext, 172, ApexParser.RULE_arguments); + let _la: number; + try { + this.enterOuterAlt(localContext, 1); + { + this.state = 1111; + this.match(ApexParser.LPAREN); + this.state = 1113; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if ((((_la) & ~0x1F) === 0 && ((1 << _la) & 105971724) !== 0) || ((((_la - 34)) & ~0x1F) === 0 && ((1 << (_la - 34)) & 4294607707) !== 0) || ((((_la - 66)) & ~0x1F) === 0 && ((1 << (_la - 66)) & 4294967295) !== 0) || ((((_la - 98)) & ~0x1F) === 0 && ((1 << (_la - 98)) & 4294967295) !== 0) || ((((_la - 130)) & ~0x1F) === 0 && ((1 << (_la - 130)) & 4294967295) !== 0) || ((((_la - 162)) & ~0x1F) === 0 && ((1 << (_la - 162)) & 3758090239) !== 0) || ((((_la - 194)) & ~0x1F) === 0 && ((1 << (_la - 194)) & 3758293271) !== 0) || _la === 226 || _la === 244) { + { + this.state = 1112; + this.expressionList(); + } + } + + this.state = 1115; + this.match(ApexParser.RPAREN); + } + } + catch (re) { + if (re instanceof antlr.RecognitionException) { + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return localContext; + } + public soqlLiteral(): SoqlLiteralContext { + const localContext = new SoqlLiteralContext(this.context, this.state); + this.enterRule(localContext, 174, ApexParser.RULE_soqlLiteral); + try { + this.enterOuterAlt(localContext, 1); + { + this.state = 1117; + this.match(ApexParser.LBRACK); + this.state = 1118; + this.query(); + this.state = 1119; + this.match(ApexParser.RBRACK); + } + } + catch (re) { + if (re instanceof antlr.RecognitionException) { + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return localContext; + } + public query(): QueryContext { + const localContext = new QueryContext(this.context, this.state); + this.enterRule(localContext, 176, ApexParser.RULE_query); + let _la: number; + try { + this.enterOuterAlt(localContext, 1); + { + this.state = 1121; + this.match(ApexParser.SELECT); + this.state = 1122; + this.selectList(); + this.state = 1123; + this.match(ApexParser.FROM); + this.state = 1124; + this.fromNameList(); + this.state = 1126; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 63) { + { + this.state = 1125; + this.usingScope(); + } + } + + this.state = 1129; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 65) { + { + this.state = 1128; + this.whereClause(); + } + } + + this.state = 1132; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 53) { + { + this.state = 1131; + this.withClause(); + } + } + + this.state = 1135; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 89) { + { + this.state = 1134; + this.groupByClause(); + } + } + + this.state = 1138; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 66) { + { + this.state = 1137; + this.orderByClause(); + } + } + + this.state = 1141; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 68) { + { + this.state = 1140; + this.limitClause(); + } + } + + this.state = 1144; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 96) { + { + this.state = 1143; + this.offsetClause(); + } + } + + this.state = 1147; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 90) { + { + this.state = 1146; + this.allRowsClause(); + } + } + + this.state = 1149; + this.forClauses(); + this.state = 1152; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 46) { + { + this.state = 1150; + this.match(ApexParser.UPDATE); + this.state = 1151; + this.updateList(); + } + } + + } + } + catch (re) { + if (re instanceof antlr.RecognitionException) { + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return localContext; + } + public subQuery(): SubQueryContext { + const localContext = new SubQueryContext(this.context, this.state); + this.enterRule(localContext, 178, ApexParser.RULE_subQuery); + let _la: number; + try { + this.enterOuterAlt(localContext, 1); + { + this.state = 1154; + this.match(ApexParser.SELECT); + this.state = 1155; + this.subFieldList(); + this.state = 1156; + this.match(ApexParser.FROM); + this.state = 1157; + this.fromNameList(); + this.state = 1159; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 65) { + { + this.state = 1158; + this.whereClause(); + } + } + + this.state = 1162; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 66) { + { + this.state = 1161; + this.orderByClause(); + } + } + + this.state = 1165; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 68) { + { + this.state = 1164; + this.limitClause(); + } + } + + this.state = 1167; + this.forClauses(); + this.state = 1170; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 46) { + { + this.state = 1168; + this.match(ApexParser.UPDATE); + this.state = 1169; + this.updateList(); + } + } + + } + } + catch (re) { + if (re instanceof antlr.RecognitionException) { + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return localContext; + } + public selectList(): SelectListContext { + const localContext = new SelectListContext(this.context, this.state); + this.enterRule(localContext, 180, ApexParser.RULE_selectList); + let _la: number; + try { + this.enterOuterAlt(localContext, 1); + { + this.state = 1172; + this.selectEntry(); + this.state = 1177; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + while (_la === 205) { + { + { + this.state = 1173; + this.match(ApexParser.COMMA); + this.state = 1174; + this.selectEntry(); + } + } + this.state = 1179; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + } + } + } + catch (re) { + if (re instanceof antlr.RecognitionException) { + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return localContext; + } + public selectEntry(): SelectEntryContext { + const localContext = new SelectEntryContext(this.context, this.state); + this.enterRule(localContext, 182, ApexParser.RULE_selectEntry); + try { + this.state = 1195; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 119, this.context) ) { + case 1: + this.enterOuterAlt(localContext, 1); + { + this.state = 1180; + this.fieldName(); + this.state = 1182; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 116, this.context) ) { + case 1: + { + this.state = 1181; + this.soqlId(); + } + break; + } + } + break; + case 2: + this.enterOuterAlt(localContext, 2); + { + this.state = 1184; + this.soqlFunction(); + this.state = 1186; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 117, this.context) ) { + case 1: + { + this.state = 1185; + this.soqlId(); + } + break; + } + } + break; + case 3: + this.enterOuterAlt(localContext, 3); + { + this.state = 1188; + this.match(ApexParser.LPAREN); + this.state = 1189; + this.subQuery(); + this.state = 1190; + this.match(ApexParser.RPAREN); + this.state = 1192; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 118, this.context) ) { + case 1: + { + this.state = 1191; + this.soqlId(); + } + break; + } + } + break; + case 4: + this.enterOuterAlt(localContext, 4); + { + this.state = 1194; + this.typeOf(); + } + break; + } + } + catch (re) { + if (re instanceof antlr.RecognitionException) { + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return localContext; + } + public fieldName(): FieldNameContext { + const localContext = new FieldNameContext(this.context, this.state); + this.enterRule(localContext, 184, ApexParser.RULE_fieldName); + let _la: number; + try { + this.enterOuterAlt(localContext, 1); + { + this.state = 1197; + this.soqlId(); + this.state = 1202; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + while (_la === 206) { + { + { + this.state = 1198; + this.match(ApexParser.DOT); + this.state = 1199; + this.soqlId(); + } + } + this.state = 1204; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + } + } + } + catch (re) { + if (re instanceof antlr.RecognitionException) { + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return localContext; + } + public fromNameList(): FromNameListContext { + const localContext = new FromNameListContext(this.context, this.state); + this.enterRule(localContext, 186, ApexParser.RULE_fromNameList); + let _la: number; + try { + this.enterOuterAlt(localContext, 1); + { + this.state = 1205; + this.fieldName(); + this.state = 1207; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 121, this.context) ) { + case 1: + { + this.state = 1206; + this.soqlId(); + } + break; + } + this.state = 1216; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + while (_la === 205) { + { + { + this.state = 1209; + this.match(ApexParser.COMMA); + this.state = 1210; + this.fieldName(); + this.state = 1212; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 122, this.context) ) { + case 1: + { + this.state = 1211; + this.soqlId(); + } + break; + } + } + } + this.state = 1218; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + } + } + } + catch (re) { + if (re instanceof antlr.RecognitionException) { + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return localContext; + } + public subFieldList(): SubFieldListContext { + const localContext = new SubFieldListContext(this.context, this.state); + this.enterRule(localContext, 188, ApexParser.RULE_subFieldList); + let _la: number; + try { + this.enterOuterAlt(localContext, 1); + { + this.state = 1219; + this.subFieldEntry(); + this.state = 1224; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + while (_la === 205) { + { + { + this.state = 1220; + this.match(ApexParser.COMMA); + this.state = 1221; + this.subFieldEntry(); + } + } + this.state = 1226; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + } + } + } + catch (re) { + if (re instanceof antlr.RecognitionException) { + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return localContext; + } + public subFieldEntry(): SubFieldEntryContext { + const localContext = new SubFieldEntryContext(this.context, this.state); + this.enterRule(localContext, 190, ApexParser.RULE_subFieldEntry); + try { + this.state = 1236; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 127, this.context) ) { + case 1: + this.enterOuterAlt(localContext, 1); + { + this.state = 1227; + this.fieldName(); + this.state = 1229; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 125, this.context) ) { + case 1: + { + this.state = 1228; + this.soqlId(); + } + break; + } + } + break; + case 2: + this.enterOuterAlt(localContext, 2); + { + this.state = 1231; + this.soqlFunction(); + this.state = 1233; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 126, this.context) ) { + case 1: + { + this.state = 1232; + this.soqlId(); + } + break; + } + } + break; + case 3: + this.enterOuterAlt(localContext, 3); + { + this.state = 1235; + this.typeOf(); + } + break; + } + } + catch (re) { + if (re instanceof antlr.RecognitionException) { + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return localContext; + } + public soqlFieldsParameter(): SoqlFieldsParameterContext { + const localContext = new SoqlFieldsParameterContext(this.context, this.state); + this.enterRule(localContext, 192, ApexParser.RULE_soqlFieldsParameter); + let _la: number; + try { + this.enterOuterAlt(localContext, 1); + { + this.state = 1238; + _la = this.tokenStream.LA(1); + if(!(((((_la - 90)) & ~0x1F) === 0 && ((1 << (_la - 90)) & 6291457) !== 0))) { + this.errorHandler.recoverInline(this); + } + else { + this.errorHandler.reportMatch(this); + this.consume(); + } + } + } + catch (re) { + if (re instanceof antlr.RecognitionException) { + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return localContext; + } + public soqlFunction(): SoqlFunctionContext { + const localContext = new SoqlFunctionContext(this.context, this.state); + this.enterRule(localContext, 194, ApexParser.RULE_soqlFunction); + try { + this.state = 1362; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 128, this.context) ) { + case 1: + this.enterOuterAlt(localContext, 1); + { + this.state = 1240; + this.match(ApexParser.AVG); + this.state = 1241; + this.match(ApexParser.LPAREN); + this.state = 1242; + this.fieldName(); + this.state = 1243; + this.match(ApexParser.RPAREN); + } + break; + case 2: + this.enterOuterAlt(localContext, 2); + { + this.state = 1245; + this.match(ApexParser.COUNT); + this.state = 1246; + this.match(ApexParser.LPAREN); + this.state = 1247; + this.match(ApexParser.RPAREN); + } + break; + case 3: + this.enterOuterAlt(localContext, 3); + { + this.state = 1248; + this.match(ApexParser.COUNT); + this.state = 1249; + this.match(ApexParser.LPAREN); + this.state = 1250; + this.fieldName(); + this.state = 1251; + this.match(ApexParser.RPAREN); + } + break; + case 4: + this.enterOuterAlt(localContext, 4); + { + this.state = 1253; + this.match(ApexParser.COUNT_DISTINCT); + this.state = 1254; + this.match(ApexParser.LPAREN); + this.state = 1255; + this.fieldName(); + this.state = 1256; + this.match(ApexParser.RPAREN); + } + break; + case 5: + this.enterOuterAlt(localContext, 5); + { + this.state = 1258; + this.match(ApexParser.MIN); + this.state = 1259; + this.match(ApexParser.LPAREN); + this.state = 1260; + this.fieldName(); + this.state = 1261; + this.match(ApexParser.RPAREN); + } + break; + case 6: + this.enterOuterAlt(localContext, 6); + { + this.state = 1263; + this.match(ApexParser.MAX); + this.state = 1264; + this.match(ApexParser.LPAREN); + this.state = 1265; + this.fieldName(); + this.state = 1266; + this.match(ApexParser.RPAREN); + } + break; + case 7: + this.enterOuterAlt(localContext, 7); + { + this.state = 1268; + this.match(ApexParser.SUM); + this.state = 1269; + this.match(ApexParser.LPAREN); + this.state = 1270; + this.fieldName(); + this.state = 1271; + this.match(ApexParser.RPAREN); + } + break; + case 8: + this.enterOuterAlt(localContext, 8); + { + this.state = 1273; + this.match(ApexParser.TOLABEL); + this.state = 1274; + this.match(ApexParser.LPAREN); + this.state = 1275; + this.fieldName(); + this.state = 1276; + this.match(ApexParser.RPAREN); + } + break; + case 9: + this.enterOuterAlt(localContext, 9); + { + this.state = 1278; + this.match(ApexParser.FORMAT); + this.state = 1279; + this.match(ApexParser.LPAREN); + this.state = 1280; + this.fieldName(); + this.state = 1281; + this.match(ApexParser.RPAREN); + } + break; + case 10: + this.enterOuterAlt(localContext, 10); + { + this.state = 1283; + this.match(ApexParser.CALENDAR_MONTH); + this.state = 1284; + this.match(ApexParser.LPAREN); + this.state = 1285; + this.dateFieldName(); + this.state = 1286; + this.match(ApexParser.RPAREN); + } + break; + case 11: + this.enterOuterAlt(localContext, 11); + { + this.state = 1288; + this.match(ApexParser.CALENDAR_QUARTER); + this.state = 1289; + this.match(ApexParser.LPAREN); + this.state = 1290; + this.dateFieldName(); + this.state = 1291; + this.match(ApexParser.RPAREN); + } + break; + case 12: + this.enterOuterAlt(localContext, 12); + { + this.state = 1293; + this.match(ApexParser.CALENDAR_YEAR); + this.state = 1294; + this.match(ApexParser.LPAREN); + this.state = 1295; + this.dateFieldName(); + this.state = 1296; + this.match(ApexParser.RPAREN); + } + break; + case 13: + this.enterOuterAlt(localContext, 13); + { + this.state = 1298; + this.match(ApexParser.DAY_IN_MONTH); + this.state = 1299; + this.match(ApexParser.LPAREN); + this.state = 1300; + this.dateFieldName(); + this.state = 1301; + this.match(ApexParser.RPAREN); + } + break; + case 14: + this.enterOuterAlt(localContext, 14); + { + this.state = 1303; + this.match(ApexParser.DAY_IN_WEEK); + this.state = 1304; + this.match(ApexParser.LPAREN); + this.state = 1305; + this.dateFieldName(); + this.state = 1306; + this.match(ApexParser.RPAREN); + } + break; + case 15: + this.enterOuterAlt(localContext, 15); + { + this.state = 1308; + this.match(ApexParser.DAY_IN_YEAR); + this.state = 1309; + this.match(ApexParser.LPAREN); + this.state = 1310; + this.dateFieldName(); + this.state = 1311; + this.match(ApexParser.RPAREN); + } + break; + case 16: + this.enterOuterAlt(localContext, 16); + { + this.state = 1313; + this.match(ApexParser.DAY_ONLY); + this.state = 1314; + this.match(ApexParser.LPAREN); + this.state = 1315; + this.dateFieldName(); + this.state = 1316; + this.match(ApexParser.RPAREN); + } + break; + case 17: + this.enterOuterAlt(localContext, 17); + { + this.state = 1318; + this.match(ApexParser.FISCAL_MONTH); + this.state = 1319; + this.match(ApexParser.LPAREN); + this.state = 1320; + this.dateFieldName(); + this.state = 1321; + this.match(ApexParser.RPAREN); + } + break; + case 18: + this.enterOuterAlt(localContext, 18); + { + this.state = 1323; + this.match(ApexParser.FISCAL_QUARTER); + this.state = 1324; + this.match(ApexParser.LPAREN); + this.state = 1325; + this.dateFieldName(); + this.state = 1326; + this.match(ApexParser.RPAREN); + } + break; + case 19: + this.enterOuterAlt(localContext, 19); + { + this.state = 1328; + this.match(ApexParser.FISCAL_YEAR); + this.state = 1329; + this.match(ApexParser.LPAREN); + this.state = 1330; + this.dateFieldName(); + this.state = 1331; + this.match(ApexParser.RPAREN); + } + break; + case 20: + this.enterOuterAlt(localContext, 20); + { + this.state = 1333; + this.match(ApexParser.HOUR_IN_DAY); + this.state = 1334; + this.match(ApexParser.LPAREN); + this.state = 1335; + this.dateFieldName(); + this.state = 1336; + this.match(ApexParser.RPAREN); + } + break; + case 21: + this.enterOuterAlt(localContext, 21); + { + this.state = 1338; + this.match(ApexParser.WEEK_IN_MONTH); + this.state = 1339; + this.match(ApexParser.LPAREN); + this.state = 1340; + this.dateFieldName(); + this.state = 1341; + this.match(ApexParser.RPAREN); + } + break; + case 22: + this.enterOuterAlt(localContext, 22); + { + this.state = 1343; + this.match(ApexParser.WEEK_IN_YEAR); + this.state = 1344; + this.match(ApexParser.LPAREN); + this.state = 1345; + this.dateFieldName(); + this.state = 1346; + this.match(ApexParser.RPAREN); + } + break; + case 23: + this.enterOuterAlt(localContext, 23); + { + this.state = 1348; + this.match(ApexParser.FIELDS); + this.state = 1349; + this.match(ApexParser.LPAREN); + this.state = 1350; + this.soqlFieldsParameter(); + this.state = 1351; + this.match(ApexParser.RPAREN); + } + break; + case 24: + this.enterOuterAlt(localContext, 24); + { + this.state = 1353; + this.match(ApexParser.DISTANCE); + this.state = 1354; + this.match(ApexParser.LPAREN); + this.state = 1355; + this.locationValue(); + this.state = 1356; + this.match(ApexParser.COMMA); + this.state = 1357; + this.locationValue(); + this.state = 1358; + this.match(ApexParser.COMMA); + this.state = 1359; + this.match(ApexParser.StringLiteral); + this.state = 1360; + this.match(ApexParser.RPAREN); + } + break; + } + } + catch (re) { + if (re instanceof antlr.RecognitionException) { + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return localContext; + } + public dateFieldName(): DateFieldNameContext { + const localContext = new DateFieldNameContext(this.context, this.state); + this.enterRule(localContext, 196, ApexParser.RULE_dateFieldName); + try { + this.state = 1370; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 129, this.context) ) { + case 1: + this.enterOuterAlt(localContext, 1); + { + this.state = 1364; + this.match(ApexParser.CONVERT_TIMEZONE); + this.state = 1365; + this.match(ApexParser.LPAREN); + this.state = 1366; + this.fieldName(); + this.state = 1367; + this.match(ApexParser.RPAREN); + } + break; + case 2: + this.enterOuterAlt(localContext, 2); + { + this.state = 1369; + this.fieldName(); + } + break; + } + } + catch (re) { + if (re instanceof antlr.RecognitionException) { + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return localContext; + } + public locationValue(): LocationValueContext { + const localContext = new LocationValueContext(this.context, this.state); + this.enterRule(localContext, 198, ApexParser.RULE_locationValue); + try { + this.state = 1381; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 130, this.context) ) { + case 1: + this.enterOuterAlt(localContext, 1); + { + this.state = 1372; + this.fieldName(); + } + break; + case 2: + this.enterOuterAlt(localContext, 2); + { + this.state = 1373; + this.boundExpression(); + } + break; + case 3: + this.enterOuterAlt(localContext, 3); + { + this.state = 1374; + this.match(ApexParser.GEOLOCATION); + this.state = 1375; + this.match(ApexParser.LPAREN); + this.state = 1376; + this.coordinateValue(); + this.state = 1377; + this.match(ApexParser.COMMA); + this.state = 1378; + this.coordinateValue(); + this.state = 1379; + this.match(ApexParser.RPAREN); + } + break; + } + } + catch (re) { + if (re instanceof antlr.RecognitionException) { + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return localContext; + } + public coordinateValue(): CoordinateValueContext { + const localContext = new CoordinateValueContext(this.context, this.state); + this.enterRule(localContext, 200, ApexParser.RULE_coordinateValue); + try { + this.state = 1385; + this.errorHandler.sync(this); + switch (this.tokenStream.LA(1)) { + case ApexParser.IntegerLiteral: + case ApexParser.NumberLiteral: + case ApexParser.ADD: + case ApexParser.SUB: + this.enterOuterAlt(localContext, 1); + { + this.state = 1383; + this.signedNumber(); + } + break; + case ApexParser.COLON: + this.enterOuterAlt(localContext, 2); + { + this.state = 1384; + this.boundExpression(); + } + break; + default: + throw new antlr.NoViableAltException(this); + } + } + catch (re) { + if (re instanceof antlr.RecognitionException) { + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return localContext; + } + public typeOf(): TypeOfContext { + const localContext = new TypeOfContext(this.context, this.state); + this.enterRule(localContext, 202, ApexParser.RULE_typeOf); + let _la: number; + try { + this.enterOuterAlt(localContext, 1); + { + this.state = 1387; + this.match(ApexParser.TYPEOF); + this.state = 1388; + this.fieldName(); + this.state = 1390; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + do { + { + { + this.state = 1389; + this.whenClause(); + } + } + this.state = 1392; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + } while (_la === 51); + this.state = 1395; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 10) { + { + this.state = 1394; + this.elseClause(); + } + } + + this.state = 1397; + this.match(ApexParser.END); + } + } + catch (re) { + if (re instanceof antlr.RecognitionException) { + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return localContext; + } + public whenClause(): WhenClauseContext { + const localContext = new WhenClauseContext(this.context, this.state); + this.enterRule(localContext, 204, ApexParser.RULE_whenClause); + try { + this.enterOuterAlt(localContext, 1); + { + this.state = 1399; + this.match(ApexParser.WHEN); + this.state = 1400; + this.fieldName(); + this.state = 1401; + this.match(ApexParser.THEN); + this.state = 1402; + this.fieldNameList(); + } + } + catch (re) { + if (re instanceof antlr.RecognitionException) { + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return localContext; + } + public elseClause(): ElseClauseContext { + const localContext = new ElseClauseContext(this.context, this.state); + this.enterRule(localContext, 206, ApexParser.RULE_elseClause); + try { + this.enterOuterAlt(localContext, 1); + { + this.state = 1404; + this.match(ApexParser.ELSE); + this.state = 1405; + this.fieldNameList(); + } + } + catch (re) { + if (re instanceof antlr.RecognitionException) { + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return localContext; + } + public fieldNameList(): FieldNameListContext { + const localContext = new FieldNameListContext(this.context, this.state); + this.enterRule(localContext, 208, ApexParser.RULE_fieldNameList); + let _la: number; + try { + this.enterOuterAlt(localContext, 1); + { + this.state = 1407; + this.fieldName(); + this.state = 1412; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + while (_la === 205) { + { + { + this.state = 1408; + this.match(ApexParser.COMMA); + this.state = 1409; + this.fieldName(); + } + } + this.state = 1414; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + } + } + } + catch (re) { + if (re instanceof antlr.RecognitionException) { + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return localContext; + } + public usingScope(): UsingScopeContext { + const localContext = new UsingScopeContext(this.context, this.state); + this.enterRule(localContext, 210, ApexParser.RULE_usingScope); + try { + this.enterOuterAlt(localContext, 1); + { + this.state = 1415; + this.match(ApexParser.USING); + this.state = 1416; + this.match(ApexParser.SCOPE); + this.state = 1417; + this.soqlId(); + } + } + catch (re) { + if (re instanceof antlr.RecognitionException) { + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return localContext; + } + public whereClause(): WhereClauseContext { + const localContext = new WhereClauseContext(this.context, this.state); + this.enterRule(localContext, 212, ApexParser.RULE_whereClause); + try { + this.enterOuterAlt(localContext, 1); + { + this.state = 1419; + this.match(ApexParser.WHERE); + this.state = 1420; + this.logicalExpression(); + } + } + catch (re) { + if (re instanceof antlr.RecognitionException) { + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return localContext; + } + public logicalExpression(): LogicalExpressionContext { + const localContext = new LogicalExpressionContext(this.context, this.state); + this.enterRule(localContext, 214, ApexParser.RULE_logicalExpression); + let _la: number; + try { + this.state = 1440; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 137, this.context) ) { + case 1: + this.enterOuterAlt(localContext, 1); + { + this.state = 1422; + this.conditionalExpression(); + this.state = 1427; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + while (_la === 69) { + { + { + this.state = 1423; + this.match(ApexParser.SOQLAND); + this.state = 1424; + this.conditionalExpression(); + } + } + this.state = 1429; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + } + } + break; + case 2: + this.enterOuterAlt(localContext, 2); + { + this.state = 1430; + this.conditionalExpression(); + this.state = 1435; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + while (_la === 70) { + { + { + this.state = 1431; + this.match(ApexParser.SOQLOR); + this.state = 1432; + this.conditionalExpression(); + } + } + this.state = 1437; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + } + } + break; + case 3: + this.enterOuterAlt(localContext, 3); + { + this.state = 1438; + this.match(ApexParser.NOT); + this.state = 1439; + this.conditionalExpression(); + } + break; + } + } + catch (re) { + if (re instanceof antlr.RecognitionException) { + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return localContext; + } + public conditionalExpression(): ConditionalExpressionContext { + const localContext = new ConditionalExpressionContext(this.context, this.state); + this.enterRule(localContext, 216, ApexParser.RULE_conditionalExpression); + try { + this.state = 1447; + this.errorHandler.sync(this); + switch (this.tokenStream.LA(1)) { + case ApexParser.LPAREN: + this.enterOuterAlt(localContext, 1); + { + this.state = 1442; + this.match(ApexParser.LPAREN); + this.state = 1443; + this.logicalExpression(); + this.state = 1444; + this.match(ApexParser.RPAREN); + } + break; + case ApexParser.AFTER: + case ApexParser.BEFORE: + case ApexParser.GET: + case ApexParser.INHERITED: + case ApexParser.INSTANCEOF: + case ApexParser.SET: + case ApexParser.SHARING: + case ApexParser.SWITCH: + case ApexParser.TRANSIENT: + case ApexParser.TRIGGER: + case ApexParser.WHEN: + case ApexParser.WITH: + case ApexParser.WITHOUT: + case ApexParser.SYSTEM: + case ApexParser.USER: + case ApexParser.SELECT: + case ApexParser.COUNT: + case ApexParser.FROM: + case ApexParser.AS: + case ApexParser.USING: + case ApexParser.SCOPE: + case ApexParser.WHERE: + case ApexParser.ORDER: + case ApexParser.BY: + case ApexParser.LIMIT: + case ApexParser.SOQLAND: + case ApexParser.SOQLOR: + case ApexParser.NOT: + case ApexParser.AVG: + case ApexParser.COUNT_DISTINCT: + case ApexParser.MIN: + case ApexParser.MAX: + case ApexParser.SUM: + case ApexParser.TYPEOF: + case ApexParser.END: + case ApexParser.THEN: + case ApexParser.LIKE: + case ApexParser.IN: + case ApexParser.INCLUDES: + case ApexParser.EXCLUDES: + case ApexParser.ASC: + case ApexParser.DESC: + case ApexParser.NULLS: + case ApexParser.FIRST: + case ApexParser.LAST: + case ApexParser.GROUP: + case ApexParser.ALL: + case ApexParser.ROWS: + case ApexParser.VIEW: + case ApexParser.HAVING: + case ApexParser.ROLLUP: + case ApexParser.TOLABEL: + case ApexParser.OFFSET: + case ApexParser.DATA: + case ApexParser.CATEGORY: + case ApexParser.AT: + case ApexParser.ABOVE: + case ApexParser.BELOW: + case ApexParser.ABOVE_OR_BELOW: + case ApexParser.SECURITY_ENFORCED: + case ApexParser.SYSTEM_MODE: + case ApexParser.USER_MODE: + case ApexParser.REFERENCE: + case ApexParser.CUBE: + case ApexParser.FORMAT: + case ApexParser.TRACKING: + case ApexParser.VIEWSTAT: + case ApexParser.CUSTOM: + case ApexParser.STANDARD: + case ApexParser.DISTANCE: + case ApexParser.GEOLOCATION: + case ApexParser.CALENDAR_MONTH: + case ApexParser.CALENDAR_QUARTER: + case ApexParser.CALENDAR_YEAR: + case ApexParser.DAY_IN_MONTH: + case ApexParser.DAY_IN_WEEK: + case ApexParser.DAY_IN_YEAR: + case ApexParser.DAY_ONLY: + case ApexParser.FISCAL_MONTH: + case ApexParser.FISCAL_QUARTER: + case ApexParser.FISCAL_YEAR: + case ApexParser.HOUR_IN_DAY: + case ApexParser.WEEK_IN_MONTH: + case ApexParser.WEEK_IN_YEAR: + case ApexParser.CONVERT_TIMEZONE: + case ApexParser.YESTERDAY: + case ApexParser.TODAY: + case ApexParser.TOMORROW: + case ApexParser.LAST_WEEK: + case ApexParser.THIS_WEEK: + case ApexParser.NEXT_WEEK: + case ApexParser.LAST_MONTH: + case ApexParser.THIS_MONTH: + case ApexParser.NEXT_MONTH: + case ApexParser.LAST_90_DAYS: + case ApexParser.NEXT_90_DAYS: + case ApexParser.LAST_N_DAYS_N: + case ApexParser.NEXT_N_DAYS_N: + case ApexParser.N_DAYS_AGO_N: + case ApexParser.NEXT_N_WEEKS_N: + case ApexParser.LAST_N_WEEKS_N: + case ApexParser.N_WEEKS_AGO_N: + case ApexParser.NEXT_N_MONTHS_N: + case ApexParser.LAST_N_MONTHS_N: + case ApexParser.N_MONTHS_AGO_N: + case ApexParser.THIS_QUARTER: + case ApexParser.LAST_QUARTER: + case ApexParser.NEXT_QUARTER: + case ApexParser.NEXT_N_QUARTERS_N: + case ApexParser.LAST_N_QUARTERS_N: + case ApexParser.N_QUARTERS_AGO_N: + case ApexParser.THIS_YEAR: + case ApexParser.LAST_YEAR: + case ApexParser.NEXT_YEAR: + case ApexParser.NEXT_N_YEARS_N: + case ApexParser.LAST_N_YEARS_N: + case ApexParser.N_YEARS_AGO_N: + case ApexParser.THIS_FISCAL_QUARTER: + case ApexParser.LAST_FISCAL_QUARTER: + case ApexParser.NEXT_FISCAL_QUARTER: + case ApexParser.NEXT_N_FISCAL_QUARTERS_N: + case ApexParser.LAST_N_FISCAL_QUARTERS_N: + case ApexParser.N_FISCAL_QUARTERS_AGO_N: + case ApexParser.THIS_FISCAL_YEAR: + case ApexParser.LAST_FISCAL_YEAR: + case ApexParser.NEXT_FISCAL_YEAR: + case ApexParser.NEXT_N_FISCAL_YEARS_N: + case ApexParser.LAST_N_FISCAL_YEARS_N: + case ApexParser.N_FISCAL_YEARS_AGO_N: + case ApexParser.IntegralCurrencyLiteral: + case ApexParser.FIND: + case ApexParser.EMAIL: + case ApexParser.NAME: + case ApexParser.PHONE: + case ApexParser.SIDEBAR: + case ApexParser.FIELDS: + case ApexParser.METADATA: + case ApexParser.PRICEBOOKID: + case ApexParser.NETWORK: + case ApexParser.SNIPPET: + case ApexParser.TARGET_LENGTH: + case ApexParser.DIVISION: + case ApexParser.RETURNING: + case ApexParser.LISTVIEW: + case ApexParser.Identifier: + this.enterOuterAlt(localContext, 2); + { + this.state = 1446; + this.fieldExpression(); + } + break; + default: + throw new antlr.NoViableAltException(this); + } + } + catch (re) { + if (re instanceof antlr.RecognitionException) { + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return localContext; + } + public fieldExpression(): FieldExpressionContext { + const localContext = new FieldExpressionContext(this.context, this.state); + this.enterRule(localContext, 218, ApexParser.RULE_fieldExpression); + try { + this.state = 1457; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 139, this.context) ) { + case 1: + this.enterOuterAlt(localContext, 1); + { + this.state = 1449; + this.fieldName(); + this.state = 1450; + this.comparisonOperator(); + this.state = 1451; + this.value(); + } + break; + case 2: + this.enterOuterAlt(localContext, 2); + { + this.state = 1453; + this.soqlFunction(); + this.state = 1454; + this.comparisonOperator(); + this.state = 1455; + this.value(); + } + break; + } + } + catch (re) { + if (re instanceof antlr.RecognitionException) { + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return localContext; + } + public comparisonOperator(): ComparisonOperatorContext { + const localContext = new ComparisonOperatorContext(this.context, this.state); + this.enterRule(localContext, 220, ApexParser.RULE_comparisonOperator); + try { + this.state = 1474; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 140, this.context) ) { + case 1: + this.enterOuterAlt(localContext, 1); + { + this.state = 1459; + this.match(ApexParser.ASSIGN); + } + break; + case 2: + this.enterOuterAlt(localContext, 2); + { + this.state = 1460; + this.match(ApexParser.NOTEQUAL); + } + break; + case 3: + this.enterOuterAlt(localContext, 3); + { + this.state = 1461; + this.match(ApexParser.LT); + } + break; + case 4: + this.enterOuterAlt(localContext, 4); + { + this.state = 1462; + this.match(ApexParser.GT); + } + break; + case 5: + this.enterOuterAlt(localContext, 5); + { + this.state = 1463; + this.match(ApexParser.LT); + this.state = 1464; + this.match(ApexParser.ASSIGN); + } + break; + case 6: + this.enterOuterAlt(localContext, 6); + { + this.state = 1465; + this.match(ApexParser.GT); + this.state = 1466; + this.match(ApexParser.ASSIGN); + } + break; + case 7: + this.enterOuterAlt(localContext, 7); + { + this.state = 1467; + this.match(ApexParser.LESSANDGREATER); + } + break; + case 8: + this.enterOuterAlt(localContext, 8); + { + this.state = 1468; + this.match(ApexParser.LIKE); + } + break; + case 9: + this.enterOuterAlt(localContext, 9); + { + this.state = 1469; + this.match(ApexParser.IN); + } + break; + case 10: + this.enterOuterAlt(localContext, 10); + { + this.state = 1470; + this.match(ApexParser.NOT); + this.state = 1471; + this.match(ApexParser.IN); + } + break; + case 11: + this.enterOuterAlt(localContext, 11); + { + this.state = 1472; + this.match(ApexParser.INCLUDES); + } + break; + case 12: + this.enterOuterAlt(localContext, 12); + { + this.state = 1473; + this.match(ApexParser.EXCLUDES); + } + break; + } + } + catch (re) { + if (re instanceof antlr.RecognitionException) { + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return localContext; + } + public value(): ValueContext { + const localContext = new ValueContext(this.context, this.state); + this.enterRule(localContext, 222, ApexParser.RULE_value); + let _la: number; + try { + this.state = 1496; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 143, this.context) ) { + case 1: + this.enterOuterAlt(localContext, 1); + { + this.state = 1476; + this.match(ApexParser.NULL); + } + break; + case 2: + this.enterOuterAlt(localContext, 2); + { + this.state = 1477; + this.match(ApexParser.BooleanLiteral); + } + break; + case 3: + this.enterOuterAlt(localContext, 3); + { + this.state = 1478; + this.signedNumber(); + } + break; + case 4: + this.enterOuterAlt(localContext, 4); + { + this.state = 1479; + this.match(ApexParser.StringLiteral); + } + break; + case 5: + this.enterOuterAlt(localContext, 5); + { + this.state = 1480; + this.match(ApexParser.DateLiteral); + } + break; + case 6: + this.enterOuterAlt(localContext, 6); + { + this.state = 1481; + this.match(ApexParser.DateTimeLiteral); + } + break; + case 7: + this.enterOuterAlt(localContext, 7); + { + this.state = 1482; + this.dateFormula(); + } + break; + case 8: + this.enterOuterAlt(localContext, 8); + { + this.state = 1483; + this.match(ApexParser.IntegralCurrencyLiteral); + this.state = 1488; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 206) { + { + this.state = 1484; + this.match(ApexParser.DOT); + this.state = 1486; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 192) { + { + this.state = 1485; + this.match(ApexParser.IntegerLiteral); + } + } + + } + } + + } + break; + case 9: + this.enterOuterAlt(localContext, 9); + { + this.state = 1490; + this.match(ApexParser.LPAREN); + this.state = 1491; + this.subQuery(); + this.state = 1492; + this.match(ApexParser.RPAREN); + } + break; + case 10: + this.enterOuterAlt(localContext, 10); + { + this.state = 1494; + this.valueList(); + } + break; + case 11: + this.enterOuterAlt(localContext, 11); + { + this.state = 1495; + this.boundExpression(); + } + break; + } + } + catch (re) { + if (re instanceof antlr.RecognitionException) { + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return localContext; + } + public valueList(): ValueListContext { + const localContext = new ValueListContext(this.context, this.state); + this.enterRule(localContext, 224, ApexParser.RULE_valueList); + let _la: number; + try { + this.enterOuterAlt(localContext, 1); + { + this.state = 1498; + this.match(ApexParser.LPAREN); + this.state = 1499; + this.value(); + this.state = 1504; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + while (_la === 205) { + { + { + this.state = 1500; + this.match(ApexParser.COMMA); + this.state = 1501; + this.value(); + } + } + this.state = 1506; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + } + this.state = 1507; + this.match(ApexParser.RPAREN); + } + } + catch (re) { + if (re instanceof antlr.RecognitionException) { + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return localContext; + } + public signedNumber(): SignedNumberContext { + const localContext = new SignedNumberContext(this.context, this.state); + this.enterRule(localContext, 226, ApexParser.RULE_signedNumber); + let _la: number; + try { + this.enterOuterAlt(localContext, 1); + { + this.state = 1510; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 225 || _la === 226) { + { + this.state = 1509; + _la = this.tokenStream.LA(1); + if(!(_la === 225 || _la === 226)) { + this.errorHandler.recoverInline(this); + } + else { + this.errorHandler.reportMatch(this); + this.consume(); + } + } + } + + this.state = 1512; + _la = this.tokenStream.LA(1); + if(!(_la === 192 || _la === 194)) { + this.errorHandler.recoverInline(this); + } + else { + this.errorHandler.reportMatch(this); + this.consume(); + } + } + } + catch (re) { + if (re instanceof antlr.RecognitionException) { + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return localContext; + } + public withClause(): WithClauseContext { + const localContext = new WithClauseContext(this.context, this.state); + this.enterRule(localContext, 228, ApexParser.RULE_withClause); + try { + this.state = 1526; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 146, this.context) ) { + case 1: + this.enterOuterAlt(localContext, 1); + { + this.state = 1514; + this.match(ApexParser.WITH); + this.state = 1515; + this.match(ApexParser.DATA); + this.state = 1516; + this.match(ApexParser.CATEGORY); + this.state = 1517; + this.filteringExpression(); + } + break; + case 2: + this.enterOuterAlt(localContext, 2); + { + this.state = 1518; + this.match(ApexParser.WITH); + this.state = 1519; + this.match(ApexParser.SECURITY_ENFORCED); + } + break; + case 3: + this.enterOuterAlt(localContext, 3); + { + this.state = 1520; + this.match(ApexParser.WITH); + this.state = 1521; + this.match(ApexParser.SYSTEM_MODE); + } + break; + case 4: + this.enterOuterAlt(localContext, 4); + { + this.state = 1522; + this.match(ApexParser.WITH); + this.state = 1523; + this.match(ApexParser.USER_MODE); + } + break; + case 5: + this.enterOuterAlt(localContext, 5); + { + this.state = 1524; + this.match(ApexParser.WITH); + this.state = 1525; + this.logicalExpression(); + } + break; + } + } + catch (re) { + if (re instanceof antlr.RecognitionException) { + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return localContext; + } + public filteringExpression(): FilteringExpressionContext { + const localContext = new FilteringExpressionContext(this.context, this.state); + this.enterRule(localContext, 230, ApexParser.RULE_filteringExpression); + let _la: number; + try { + this.enterOuterAlt(localContext, 1); + { + this.state = 1528; + this.dataCategorySelection(); + this.state = 1533; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + while (_la === 221) { + { + { + this.state = 1529; + this.match(ApexParser.AND); + this.state = 1530; + this.dataCategorySelection(); + } + } + this.state = 1535; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + } + } + } + catch (re) { + if (re instanceof antlr.RecognitionException) { + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return localContext; + } + public dataCategorySelection(): DataCategorySelectionContext { + const localContext = new DataCategorySelectionContext(this.context, this.state); + this.enterRule(localContext, 232, ApexParser.RULE_dataCategorySelection); + try { + this.enterOuterAlt(localContext, 1); + { + this.state = 1536; + this.soqlId(); + this.state = 1537; + this.filteringSelector(); + this.state = 1538; + this.dataCategoryName(); + } + } + catch (re) { + if (re instanceof antlr.RecognitionException) { + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return localContext; + } + public dataCategoryName(): DataCategoryNameContext { + const localContext = new DataCategoryNameContext(this.context, this.state); + this.enterRule(localContext, 234, ApexParser.RULE_dataCategoryName); + let _la: number; + try { + this.state = 1552; + this.errorHandler.sync(this); + switch (this.tokenStream.LA(1)) { + case ApexParser.AFTER: + case ApexParser.BEFORE: + case ApexParser.GET: + case ApexParser.INHERITED: + case ApexParser.INSTANCEOF: + case ApexParser.SET: + case ApexParser.SHARING: + case ApexParser.SWITCH: + case ApexParser.TRANSIENT: + case ApexParser.TRIGGER: + case ApexParser.WHEN: + case ApexParser.WITH: + case ApexParser.WITHOUT: + case ApexParser.SYSTEM: + case ApexParser.USER: + case ApexParser.SELECT: + case ApexParser.COUNT: + case ApexParser.FROM: + case ApexParser.AS: + case ApexParser.USING: + case ApexParser.SCOPE: + case ApexParser.WHERE: + case ApexParser.ORDER: + case ApexParser.BY: + case ApexParser.LIMIT: + case ApexParser.SOQLAND: + case ApexParser.SOQLOR: + case ApexParser.NOT: + case ApexParser.AVG: + case ApexParser.COUNT_DISTINCT: + case ApexParser.MIN: + case ApexParser.MAX: + case ApexParser.SUM: + case ApexParser.TYPEOF: + case ApexParser.END: + case ApexParser.THEN: + case ApexParser.LIKE: + case ApexParser.IN: + case ApexParser.INCLUDES: + case ApexParser.EXCLUDES: + case ApexParser.ASC: + case ApexParser.DESC: + case ApexParser.NULLS: + case ApexParser.FIRST: + case ApexParser.LAST: + case ApexParser.GROUP: + case ApexParser.ALL: + case ApexParser.ROWS: + case ApexParser.VIEW: + case ApexParser.HAVING: + case ApexParser.ROLLUP: + case ApexParser.TOLABEL: + case ApexParser.OFFSET: + case ApexParser.DATA: + case ApexParser.CATEGORY: + case ApexParser.AT: + case ApexParser.ABOVE: + case ApexParser.BELOW: + case ApexParser.ABOVE_OR_BELOW: + case ApexParser.SECURITY_ENFORCED: + case ApexParser.SYSTEM_MODE: + case ApexParser.USER_MODE: + case ApexParser.REFERENCE: + case ApexParser.CUBE: + case ApexParser.FORMAT: + case ApexParser.TRACKING: + case ApexParser.VIEWSTAT: + case ApexParser.CUSTOM: + case ApexParser.STANDARD: + case ApexParser.DISTANCE: + case ApexParser.GEOLOCATION: + case ApexParser.CALENDAR_MONTH: + case ApexParser.CALENDAR_QUARTER: + case ApexParser.CALENDAR_YEAR: + case ApexParser.DAY_IN_MONTH: + case ApexParser.DAY_IN_WEEK: + case ApexParser.DAY_IN_YEAR: + case ApexParser.DAY_ONLY: + case ApexParser.FISCAL_MONTH: + case ApexParser.FISCAL_QUARTER: + case ApexParser.FISCAL_YEAR: + case ApexParser.HOUR_IN_DAY: + case ApexParser.WEEK_IN_MONTH: + case ApexParser.WEEK_IN_YEAR: + case ApexParser.CONVERT_TIMEZONE: + case ApexParser.YESTERDAY: + case ApexParser.TODAY: + case ApexParser.TOMORROW: + case ApexParser.LAST_WEEK: + case ApexParser.THIS_WEEK: + case ApexParser.NEXT_WEEK: + case ApexParser.LAST_MONTH: + case ApexParser.THIS_MONTH: + case ApexParser.NEXT_MONTH: + case ApexParser.LAST_90_DAYS: + case ApexParser.NEXT_90_DAYS: + case ApexParser.LAST_N_DAYS_N: + case ApexParser.NEXT_N_DAYS_N: + case ApexParser.N_DAYS_AGO_N: + case ApexParser.NEXT_N_WEEKS_N: + case ApexParser.LAST_N_WEEKS_N: + case ApexParser.N_WEEKS_AGO_N: + case ApexParser.NEXT_N_MONTHS_N: + case ApexParser.LAST_N_MONTHS_N: + case ApexParser.N_MONTHS_AGO_N: + case ApexParser.THIS_QUARTER: + case ApexParser.LAST_QUARTER: + case ApexParser.NEXT_QUARTER: + case ApexParser.NEXT_N_QUARTERS_N: + case ApexParser.LAST_N_QUARTERS_N: + case ApexParser.N_QUARTERS_AGO_N: + case ApexParser.THIS_YEAR: + case ApexParser.LAST_YEAR: + case ApexParser.NEXT_YEAR: + case ApexParser.NEXT_N_YEARS_N: + case ApexParser.LAST_N_YEARS_N: + case ApexParser.N_YEARS_AGO_N: + case ApexParser.THIS_FISCAL_QUARTER: + case ApexParser.LAST_FISCAL_QUARTER: + case ApexParser.NEXT_FISCAL_QUARTER: + case ApexParser.NEXT_N_FISCAL_QUARTERS_N: + case ApexParser.LAST_N_FISCAL_QUARTERS_N: + case ApexParser.N_FISCAL_QUARTERS_AGO_N: + case ApexParser.THIS_FISCAL_YEAR: + case ApexParser.LAST_FISCAL_YEAR: + case ApexParser.NEXT_FISCAL_YEAR: + case ApexParser.NEXT_N_FISCAL_YEARS_N: + case ApexParser.LAST_N_FISCAL_YEARS_N: + case ApexParser.N_FISCAL_YEARS_AGO_N: + case ApexParser.IntegralCurrencyLiteral: + case ApexParser.FIND: + case ApexParser.EMAIL: + case ApexParser.NAME: + case ApexParser.PHONE: + case ApexParser.SIDEBAR: + case ApexParser.FIELDS: + case ApexParser.METADATA: + case ApexParser.PRICEBOOKID: + case ApexParser.NETWORK: + case ApexParser.SNIPPET: + case ApexParser.TARGET_LENGTH: + case ApexParser.DIVISION: + case ApexParser.RETURNING: + case ApexParser.LISTVIEW: + case ApexParser.Identifier: + this.enterOuterAlt(localContext, 1); + { + this.state = 1540; + this.soqlId(); + } + break; + case ApexParser.LPAREN: + this.enterOuterAlt(localContext, 2); + { + this.state = 1541; + this.match(ApexParser.LPAREN); + this.state = 1542; + this.soqlId(); + this.state = 1547; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + while (_la === 205) { + { + { + this.state = 1543; + this.match(ApexParser.COMMA); + this.state = 1544; + this.soqlId(); + } + } + this.state = 1549; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + } + this.state = 1550; + this.match(ApexParser.LPAREN); + } + break; + default: + throw new antlr.NoViableAltException(this); + } + } + catch (re) { + if (re instanceof antlr.RecognitionException) { + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return localContext; + } + public filteringSelector(): FilteringSelectorContext { + const localContext = new FilteringSelectorContext(this.context, this.state); + this.enterRule(localContext, 236, ApexParser.RULE_filteringSelector); + let _la: number; + try { + this.enterOuterAlt(localContext, 1); + { + this.state = 1554; + _la = this.tokenStream.LA(1); + if(!(((((_la - 99)) & ~0x1F) === 0 && ((1 << (_la - 99)) & 15) !== 0))) { + this.errorHandler.recoverInline(this); + } + else { + this.errorHandler.reportMatch(this); + this.consume(); + } + } + } + catch (re) { + if (re instanceof antlr.RecognitionException) { + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return localContext; + } + public groupByClause(): GroupByClauseContext { + const localContext = new GroupByClauseContext(this.context, this.state); + this.enterRule(localContext, 238, ApexParser.RULE_groupByClause); + let _la: number; + try { + this.state = 1591; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 153, this.context) ) { + case 1: + this.enterOuterAlt(localContext, 1); + { + this.state = 1556; + this.match(ApexParser.GROUP); + this.state = 1557; + this.match(ApexParser.BY); + this.state = 1558; + this.selectList(); + this.state = 1561; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 93) { + { + this.state = 1559; + this.match(ApexParser.HAVING); + this.state = 1560; + this.logicalExpression(); + } + } + + } + break; + case 2: + this.enterOuterAlt(localContext, 2); + { + this.state = 1563; + this.match(ApexParser.GROUP); + this.state = 1564; + this.match(ApexParser.BY); + this.state = 1565; + this.match(ApexParser.ROLLUP); + this.state = 1566; + this.match(ApexParser.LPAREN); + this.state = 1567; + this.fieldName(); + this.state = 1572; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + while (_la === 205) { + { + { + this.state = 1568; + this.match(ApexParser.COMMA); + this.state = 1569; + this.fieldName(); + } + } + this.state = 1574; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + } + this.state = 1575; + this.match(ApexParser.RPAREN); + } + break; + case 3: + this.enterOuterAlt(localContext, 3); + { + this.state = 1577; + this.match(ApexParser.GROUP); + this.state = 1578; + this.match(ApexParser.BY); + this.state = 1579; + this.match(ApexParser.CUBE); + this.state = 1580; + this.match(ApexParser.LPAREN); + this.state = 1581; + this.fieldName(); + this.state = 1586; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + while (_la === 205) { + { + { + this.state = 1582; + this.match(ApexParser.COMMA); + this.state = 1583; + this.fieldName(); + } + } + this.state = 1588; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + } + this.state = 1589; + this.match(ApexParser.RPAREN); + } + break; + } + } + catch (re) { + if (re instanceof antlr.RecognitionException) { + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return localContext; + } + public orderByClause(): OrderByClauseContext { + const localContext = new OrderByClauseContext(this.context, this.state); + this.enterRule(localContext, 240, ApexParser.RULE_orderByClause); + try { + this.enterOuterAlt(localContext, 1); + { + this.state = 1593; + this.match(ApexParser.ORDER); + this.state = 1594; + this.match(ApexParser.BY); + this.state = 1595; + this.fieldOrderList(); + } + } + catch (re) { + if (re instanceof antlr.RecognitionException) { + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return localContext; + } + public fieldOrderList(): FieldOrderListContext { + const localContext = new FieldOrderListContext(this.context, this.state); + this.enterRule(localContext, 242, ApexParser.RULE_fieldOrderList); + let _la: number; + try { + this.enterOuterAlt(localContext, 1); + { + this.state = 1597; + this.fieldOrder(); + this.state = 1602; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + while (_la === 205) { + { + { + this.state = 1598; + this.match(ApexParser.COMMA); + this.state = 1599; + this.fieldOrder(); + } + } + this.state = 1604; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + } + } + } + catch (re) { + if (re instanceof antlr.RecognitionException) { + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return localContext; + } + public fieldOrder(): FieldOrderContext { + const localContext = new FieldOrderContext(this.context, this.state); + this.enterRule(localContext, 244, ApexParser.RULE_fieldOrder); + let _la: number; + try { + this.state = 1621; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 159, this.context) ) { + case 1: + this.enterOuterAlt(localContext, 1); + { + this.state = 1605; + this.fieldName(); + this.state = 1607; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 84 || _la === 85) { + { + this.state = 1606; + _la = this.tokenStream.LA(1); + if(!(_la === 84 || _la === 85)) { + this.errorHandler.recoverInline(this); + } + else { + this.errorHandler.reportMatch(this); + this.consume(); + } + } + } + + this.state = 1611; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 86) { + { + this.state = 1609; + this.match(ApexParser.NULLS); + this.state = 1610; + _la = this.tokenStream.LA(1); + if(!(_la === 87 || _la === 88)) { + this.errorHandler.recoverInline(this); + } + else { + this.errorHandler.reportMatch(this); + this.consume(); + } + } + } + + } + break; + case 2: + this.enterOuterAlt(localContext, 2); + { + this.state = 1613; + this.soqlFunction(); + this.state = 1615; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 84 || _la === 85) { + { + this.state = 1614; + _la = this.tokenStream.LA(1); + if(!(_la === 84 || _la === 85)) { + this.errorHandler.recoverInline(this); + } + else { + this.errorHandler.reportMatch(this); + this.consume(); + } + } + } + + this.state = 1619; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 86) { + { + this.state = 1617; + this.match(ApexParser.NULLS); + this.state = 1618; + _la = this.tokenStream.LA(1); + if(!(_la === 87 || _la === 88)) { + this.errorHandler.recoverInline(this); + } + else { + this.errorHandler.reportMatch(this); + this.consume(); + } + } + } + + } + break; + } + } + catch (re) { + if (re instanceof antlr.RecognitionException) { + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return localContext; + } + public limitClause(): LimitClauseContext { + const localContext = new LimitClauseContext(this.context, this.state); + this.enterRule(localContext, 246, ApexParser.RULE_limitClause); + try { + this.state = 1627; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 160, this.context) ) { + case 1: + this.enterOuterAlt(localContext, 1); + { + this.state = 1623; + this.match(ApexParser.LIMIT); + this.state = 1624; + this.match(ApexParser.IntegerLiteral); + } + break; + case 2: + this.enterOuterAlt(localContext, 2); + { + this.state = 1625; + this.match(ApexParser.LIMIT); + this.state = 1626; + this.boundExpression(); + } + break; + } + } + catch (re) { + if (re instanceof antlr.RecognitionException) { + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return localContext; + } + public offsetClause(): OffsetClauseContext { + const localContext = new OffsetClauseContext(this.context, this.state); + this.enterRule(localContext, 248, ApexParser.RULE_offsetClause); + try { + this.state = 1633; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 161, this.context) ) { + case 1: + this.enterOuterAlt(localContext, 1); + { + this.state = 1629; + this.match(ApexParser.OFFSET); + this.state = 1630; + this.match(ApexParser.IntegerLiteral); + } + break; + case 2: + this.enterOuterAlt(localContext, 2); + { + this.state = 1631; + this.match(ApexParser.OFFSET); + this.state = 1632; + this.boundExpression(); + } + break; + } + } + catch (re) { + if (re instanceof antlr.RecognitionException) { + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return localContext; + } + public allRowsClause(): AllRowsClauseContext { + const localContext = new AllRowsClauseContext(this.context, this.state); + this.enterRule(localContext, 250, ApexParser.RULE_allRowsClause); + try { + this.enterOuterAlt(localContext, 1); + { + this.state = 1635; + this.match(ApexParser.ALL); + this.state = 1636; + this.match(ApexParser.ROWS); + } + } + catch (re) { + if (re instanceof antlr.RecognitionException) { + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return localContext; + } + public forClauses(): ForClausesContext { + const localContext = new ForClausesContext(this.context, this.state); + this.enterRule(localContext, 252, ApexParser.RULE_forClauses); + let _la: number; + try { + this.enterOuterAlt(localContext, 1); + { + this.state = 1642; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + while (_la === 15) { + { + { + this.state = 1638; + this.match(ApexParser.FOR); + this.state = 1639; + _la = this.tokenStream.LA(1); + if(!(_la === 46 || _la === 92 || _la === 106)) { + this.errorHandler.recoverInline(this); + } + else { + this.errorHandler.reportMatch(this); + this.consume(); + } + } + } + this.state = 1644; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + } + } + } + catch (re) { + if (re instanceof antlr.RecognitionException) { + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return localContext; + } + public boundExpression(): BoundExpressionContext { + const localContext = new BoundExpressionContext(this.context, this.state); + this.enterRule(localContext, 254, ApexParser.RULE_boundExpression); + try { + this.enterOuterAlt(localContext, 1); + { + this.state = 1645; + this.match(ApexParser.COLON); + this.state = 1646; + this.expression(0); + } + } + catch (re) { + if (re instanceof antlr.RecognitionException) { + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return localContext; + } + public dateFormula(): DateFormulaContext { + const localContext = new DateFormulaContext(this.context, this.state); + this.enterRule(localContext, 256, ApexParser.RULE_dateFormula); + try { + this.state = 1734; + this.errorHandler.sync(this); + switch (this.tokenStream.LA(1)) { + case ApexParser.YESTERDAY: + this.enterOuterAlt(localContext, 1); + { + this.state = 1648; + this.match(ApexParser.YESTERDAY); + } + break; + case ApexParser.TODAY: + this.enterOuterAlt(localContext, 2); + { + this.state = 1649; + this.match(ApexParser.TODAY); + } + break; + case ApexParser.TOMORROW: + this.enterOuterAlt(localContext, 3); + { + this.state = 1650; + this.match(ApexParser.TOMORROW); + } + break; + case ApexParser.LAST_WEEK: + this.enterOuterAlt(localContext, 4); + { + this.state = 1651; + this.match(ApexParser.LAST_WEEK); + } + break; + case ApexParser.THIS_WEEK: + this.enterOuterAlt(localContext, 5); + { + this.state = 1652; + this.match(ApexParser.THIS_WEEK); + } + break; + case ApexParser.NEXT_WEEK: + this.enterOuterAlt(localContext, 6); + { + this.state = 1653; + this.match(ApexParser.NEXT_WEEK); + } + break; + case ApexParser.LAST_MONTH: + this.enterOuterAlt(localContext, 7); + { + this.state = 1654; + this.match(ApexParser.LAST_MONTH); + } + break; + case ApexParser.THIS_MONTH: + this.enterOuterAlt(localContext, 8); + { + this.state = 1655; + this.match(ApexParser.THIS_MONTH); + } + break; + case ApexParser.NEXT_MONTH: + this.enterOuterAlt(localContext, 9); + { + this.state = 1656; + this.match(ApexParser.NEXT_MONTH); + } + break; + case ApexParser.LAST_90_DAYS: + this.enterOuterAlt(localContext, 10); + { + this.state = 1657; + this.match(ApexParser.LAST_90_DAYS); + } + break; + case ApexParser.NEXT_90_DAYS: + this.enterOuterAlt(localContext, 11); + { + this.state = 1658; + this.match(ApexParser.NEXT_90_DAYS); + } + break; + case ApexParser.LAST_N_DAYS_N: + this.enterOuterAlt(localContext, 12); + { + this.state = 1659; + this.match(ApexParser.LAST_N_DAYS_N); + this.state = 1660; + this.match(ApexParser.COLON); + this.state = 1661; + this.signedInteger(); + } + break; + case ApexParser.NEXT_N_DAYS_N: + this.enterOuterAlt(localContext, 13); + { + this.state = 1662; + this.match(ApexParser.NEXT_N_DAYS_N); + this.state = 1663; + this.match(ApexParser.COLON); + this.state = 1664; + this.signedInteger(); + } + break; + case ApexParser.N_DAYS_AGO_N: + this.enterOuterAlt(localContext, 14); + { + this.state = 1665; + this.match(ApexParser.N_DAYS_AGO_N); + this.state = 1666; + this.match(ApexParser.COLON); + this.state = 1667; + this.signedInteger(); + } + break; + case ApexParser.NEXT_N_WEEKS_N: + this.enterOuterAlt(localContext, 15); + { + this.state = 1668; + this.match(ApexParser.NEXT_N_WEEKS_N); + this.state = 1669; + this.match(ApexParser.COLON); + this.state = 1670; + this.signedInteger(); + } + break; + case ApexParser.LAST_N_WEEKS_N: + this.enterOuterAlt(localContext, 16); + { + this.state = 1671; + this.match(ApexParser.LAST_N_WEEKS_N); + this.state = 1672; + this.match(ApexParser.COLON); + this.state = 1673; + this.signedInteger(); + } + break; + case ApexParser.N_WEEKS_AGO_N: + this.enterOuterAlt(localContext, 17); + { + this.state = 1674; + this.match(ApexParser.N_WEEKS_AGO_N); + this.state = 1675; + this.match(ApexParser.COLON); + this.state = 1676; + this.signedInteger(); + } + break; + case ApexParser.NEXT_N_MONTHS_N: + this.enterOuterAlt(localContext, 18); + { + this.state = 1677; + this.match(ApexParser.NEXT_N_MONTHS_N); + this.state = 1678; + this.match(ApexParser.COLON); + this.state = 1679; + this.signedInteger(); + } + break; + case ApexParser.LAST_N_MONTHS_N: + this.enterOuterAlt(localContext, 19); + { + this.state = 1680; + this.match(ApexParser.LAST_N_MONTHS_N); + this.state = 1681; + this.match(ApexParser.COLON); + this.state = 1682; + this.signedInteger(); + } + break; + case ApexParser.N_MONTHS_AGO_N: + this.enterOuterAlt(localContext, 20); + { + this.state = 1683; + this.match(ApexParser.N_MONTHS_AGO_N); + this.state = 1684; + this.match(ApexParser.COLON); + this.state = 1685; + this.signedInteger(); + } + break; + case ApexParser.THIS_QUARTER: + this.enterOuterAlt(localContext, 21); + { + this.state = 1686; + this.match(ApexParser.THIS_QUARTER); + } + break; + case ApexParser.LAST_QUARTER: + this.enterOuterAlt(localContext, 22); + { + this.state = 1687; + this.match(ApexParser.LAST_QUARTER); + } + break; + case ApexParser.NEXT_QUARTER: + this.enterOuterAlt(localContext, 23); + { + this.state = 1688; + this.match(ApexParser.NEXT_QUARTER); + } + break; + case ApexParser.NEXT_N_QUARTERS_N: + this.enterOuterAlt(localContext, 24); + { + this.state = 1689; + this.match(ApexParser.NEXT_N_QUARTERS_N); + this.state = 1690; + this.match(ApexParser.COLON); + this.state = 1691; + this.signedInteger(); + } + break; + case ApexParser.LAST_N_QUARTERS_N: + this.enterOuterAlt(localContext, 25); + { + this.state = 1692; + this.match(ApexParser.LAST_N_QUARTERS_N); + this.state = 1693; + this.match(ApexParser.COLON); + this.state = 1694; + this.signedInteger(); + } + break; + case ApexParser.N_QUARTERS_AGO_N: + this.enterOuterAlt(localContext, 26); + { + this.state = 1695; + this.match(ApexParser.N_QUARTERS_AGO_N); + this.state = 1696; + this.match(ApexParser.COLON); + this.state = 1697; + this.signedInteger(); + } + break; + case ApexParser.THIS_YEAR: + this.enterOuterAlt(localContext, 27); + { + this.state = 1698; + this.match(ApexParser.THIS_YEAR); + } + break; + case ApexParser.LAST_YEAR: + this.enterOuterAlt(localContext, 28); + { + this.state = 1699; + this.match(ApexParser.LAST_YEAR); + } + break; + case ApexParser.NEXT_YEAR: + this.enterOuterAlt(localContext, 29); + { + this.state = 1700; + this.match(ApexParser.NEXT_YEAR); + } + break; + case ApexParser.NEXT_N_YEARS_N: + this.enterOuterAlt(localContext, 30); + { + this.state = 1701; + this.match(ApexParser.NEXT_N_YEARS_N); + this.state = 1702; + this.match(ApexParser.COLON); + this.state = 1703; + this.signedInteger(); + } + break; + case ApexParser.LAST_N_YEARS_N: + this.enterOuterAlt(localContext, 31); + { + this.state = 1704; + this.match(ApexParser.LAST_N_YEARS_N); + this.state = 1705; + this.match(ApexParser.COLON); + this.state = 1706; + this.signedInteger(); + } + break; + case ApexParser.N_YEARS_AGO_N: + this.enterOuterAlt(localContext, 32); + { + this.state = 1707; + this.match(ApexParser.N_YEARS_AGO_N); + this.state = 1708; + this.match(ApexParser.COLON); + this.state = 1709; + this.signedInteger(); + } + break; + case ApexParser.THIS_FISCAL_QUARTER: + this.enterOuterAlt(localContext, 33); + { + this.state = 1710; + this.match(ApexParser.THIS_FISCAL_QUARTER); + } + break; + case ApexParser.LAST_FISCAL_QUARTER: + this.enterOuterAlt(localContext, 34); + { + this.state = 1711; + this.match(ApexParser.LAST_FISCAL_QUARTER); + } + break; + case ApexParser.NEXT_FISCAL_QUARTER: + this.enterOuterAlt(localContext, 35); + { + this.state = 1712; + this.match(ApexParser.NEXT_FISCAL_QUARTER); + } + break; + case ApexParser.NEXT_N_FISCAL_QUARTERS_N: + this.enterOuterAlt(localContext, 36); + { + this.state = 1713; + this.match(ApexParser.NEXT_N_FISCAL_QUARTERS_N); + this.state = 1714; + this.match(ApexParser.COLON); + this.state = 1715; + this.signedInteger(); + } + break; + case ApexParser.LAST_N_FISCAL_QUARTERS_N: + this.enterOuterAlt(localContext, 37); + { + this.state = 1716; + this.match(ApexParser.LAST_N_FISCAL_QUARTERS_N); + this.state = 1717; + this.match(ApexParser.COLON); + this.state = 1718; + this.signedInteger(); + } + break; + case ApexParser.N_FISCAL_QUARTERS_AGO_N: + this.enterOuterAlt(localContext, 38); + { + this.state = 1719; + this.match(ApexParser.N_FISCAL_QUARTERS_AGO_N); + this.state = 1720; + this.match(ApexParser.COLON); + this.state = 1721; + this.signedInteger(); + } + break; + case ApexParser.THIS_FISCAL_YEAR: + this.enterOuterAlt(localContext, 39); + { + this.state = 1722; + this.match(ApexParser.THIS_FISCAL_YEAR); + } + break; + case ApexParser.LAST_FISCAL_YEAR: + this.enterOuterAlt(localContext, 40); + { + this.state = 1723; + this.match(ApexParser.LAST_FISCAL_YEAR); + } + break; + case ApexParser.NEXT_FISCAL_YEAR: + this.enterOuterAlt(localContext, 41); + { + this.state = 1724; + this.match(ApexParser.NEXT_FISCAL_YEAR); + } + break; + case ApexParser.NEXT_N_FISCAL_YEARS_N: + this.enterOuterAlt(localContext, 42); + { + this.state = 1725; + this.match(ApexParser.NEXT_N_FISCAL_YEARS_N); + this.state = 1726; + this.match(ApexParser.COLON); + this.state = 1727; + this.signedInteger(); + } + break; + case ApexParser.LAST_N_FISCAL_YEARS_N: + this.enterOuterAlt(localContext, 43); + { + this.state = 1728; + this.match(ApexParser.LAST_N_FISCAL_YEARS_N); + this.state = 1729; + this.match(ApexParser.COLON); + this.state = 1730; + this.signedInteger(); + } + break; + case ApexParser.N_FISCAL_YEARS_AGO_N: + this.enterOuterAlt(localContext, 44); + { + this.state = 1731; + this.match(ApexParser.N_FISCAL_YEARS_AGO_N); + this.state = 1732; + this.match(ApexParser.COLON); + this.state = 1733; + this.signedInteger(); + } + break; + default: + throw new antlr.NoViableAltException(this); + } + } + catch (re) { + if (re instanceof antlr.RecognitionException) { + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return localContext; + } + public signedInteger(): SignedIntegerContext { + const localContext = new SignedIntegerContext(this.context, this.state); + this.enterRule(localContext, 258, ApexParser.RULE_signedInteger); + let _la: number; + try { + this.enterOuterAlt(localContext, 1); + { + this.state = 1737; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 225 || _la === 226) { + { + this.state = 1736; + _la = this.tokenStream.LA(1); + if(!(_la === 225 || _la === 226)) { + this.errorHandler.recoverInline(this); + } + else { + this.errorHandler.reportMatch(this); + this.consume(); + } + } + } + + this.state = 1739; + this.match(ApexParser.IntegerLiteral); + } + } + catch (re) { + if (re instanceof antlr.RecognitionException) { + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return localContext; + } + public soqlId(): SoqlIdContext { + const localContext = new SoqlIdContext(this.context, this.state); + this.enterRule(localContext, 260, ApexParser.RULE_soqlId); + try { + this.enterOuterAlt(localContext, 1); + { + this.state = 1741; + this.id(); + } + } + catch (re) { + if (re instanceof antlr.RecognitionException) { + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return localContext; + } + public soslLiteral(): SoslLiteralContext { + const localContext = new SoslLiteralContext(this.context, this.state); + this.enterRule(localContext, 262, ApexParser.RULE_soslLiteral); + try { + this.state = 1753; + this.errorHandler.sync(this); + switch (this.tokenStream.LA(1)) { + case ApexParser.FindLiteral: + this.enterOuterAlt(localContext, 1); + { + this.state = 1743; + this.match(ApexParser.FindLiteral); + this.state = 1744; + this.soslClauses(); + this.state = 1745; + this.match(ApexParser.RBRACK); + } + break; + case ApexParser.LBRACK: + this.enterOuterAlt(localContext, 2); + { + this.state = 1747; + this.match(ApexParser.LBRACK); + this.state = 1748; + this.match(ApexParser.FIND); + this.state = 1749; + this.boundExpression(); + this.state = 1750; + this.soslClauses(); + this.state = 1751; + this.match(ApexParser.RBRACK); + } + break; + default: + throw new antlr.NoViableAltException(this); + } + } + catch (re) { + if (re instanceof antlr.RecognitionException) { + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return localContext; + } + public soslLiteralAlt(): SoslLiteralAltContext { + const localContext = new SoslLiteralAltContext(this.context, this.state); + this.enterRule(localContext, 264, ApexParser.RULE_soslLiteralAlt); + try { + this.enterOuterAlt(localContext, 1); + { + this.state = 1755; + this.match(ApexParser.FindLiteralAlt); + this.state = 1756; + this.soslClauses(); + this.state = 1757; + this.match(ApexParser.RBRACK); + } + } + catch (re) { + if (re instanceof antlr.RecognitionException) { + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return localContext; + } + public soslClauses(): SoslClausesContext { + const localContext = new SoslClausesContext(this.context, this.state); + this.enterRule(localContext, 266, ApexParser.RULE_soslClauses); + let _la: number; + try { + this.enterOuterAlt(localContext, 1); + { + this.state = 1761; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 81) { + { + this.state = 1759; + this.match(ApexParser.IN); + this.state = 1760; + this.searchGroup(); + } + } + + this.state = 1765; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 188) { + { + this.state = 1763; + this.match(ApexParser.RETURNING); + this.state = 1764; + this.fieldSpecList(); + } + } + + this.state = 1771; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 168, this.context) ) { + case 1: + { + this.state = 1767; + this.match(ApexParser.WITH); + this.state = 1768; + this.match(ApexParser.DIVISION); + this.state = 1769; + this.match(ApexParser.ASSIGN); + this.state = 1770; + this.match(ApexParser.StringLiteral); + } + break; + } + this.state = 1777; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 169, this.context) ) { + case 1: + { + this.state = 1773; + this.match(ApexParser.WITH); + this.state = 1774; + this.match(ApexParser.DATA); + this.state = 1775; + this.match(ApexParser.CATEGORY); + this.state = 1776; + this.filteringExpression(); + } + break; + } + this.state = 1788; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 171, this.context) ) { + case 1: + { + this.state = 1779; + this.match(ApexParser.WITH); + this.state = 1780; + this.match(ApexParser.SNIPPET); + this.state = 1786; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 198) { + { + this.state = 1781; + this.match(ApexParser.LPAREN); + this.state = 1782; + this.match(ApexParser.TARGET_LENGTH); + this.state = 1783; + this.match(ApexParser.ASSIGN); + this.state = 1784; + this.match(ApexParser.IntegerLiteral); + this.state = 1785; + this.match(ApexParser.RPAREN); + } + } + + } + break; + } + this.state = 1797; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 172, this.context) ) { + case 1: + { + this.state = 1790; + this.match(ApexParser.WITH); + this.state = 1791; + this.match(ApexParser.NETWORK); + this.state = 1792; + this.match(ApexParser.IN); + this.state = 1793; + this.match(ApexParser.LPAREN); + this.state = 1794; + this.networkList(); + this.state = 1795; + this.match(ApexParser.RPAREN); + } + break; + } + this.state = 1803; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 173, this.context) ) { + case 1: + { + this.state = 1799; + this.match(ApexParser.WITH); + this.state = 1800; + this.match(ApexParser.NETWORK); + this.state = 1801; + this.match(ApexParser.ASSIGN); + this.state = 1802; + this.match(ApexParser.StringLiteral); + } + break; + } + this.state = 1809; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 174, this.context) ) { + case 1: + { + this.state = 1805; + this.match(ApexParser.WITH); + this.state = 1806; + this.match(ApexParser.PRICEBOOKID); + this.state = 1807; + this.match(ApexParser.ASSIGN); + this.state = 1808; + this.match(ApexParser.StringLiteral); + } + break; + } + this.state = 1815; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 53) { + { + this.state = 1811; + this.match(ApexParser.WITH); + this.state = 1812; + this.match(ApexParser.METADATA); + this.state = 1813; + this.match(ApexParser.ASSIGN); + this.state = 1814; + this.match(ApexParser.StringLiteral); + } + } + + this.state = 1818; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 68) { + { + this.state = 1817; + this.limitClause(); + } + } + + this.state = 1822; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 46) { + { + this.state = 1820; + this.match(ApexParser.UPDATE); + this.state = 1821; + this.updateList(); + } + } + + } + } + catch (re) { + if (re instanceof antlr.RecognitionException) { + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return localContext; + } + public searchGroup(): SearchGroupContext { + const localContext = new SearchGroupContext(this.context, this.state); + this.enterRule(localContext, 268, ApexParser.RULE_searchGroup); + let _la: number; + try { + this.enterOuterAlt(localContext, 1); + { + this.state = 1824; + _la = this.tokenStream.LA(1); + if(!(_la === 90 || ((((_la - 177)) & ~0x1F) === 0 && ((1 << (_la - 177)) & 15) !== 0))) { + this.errorHandler.recoverInline(this); + } + else { + this.errorHandler.reportMatch(this); + this.consume(); + } + this.state = 1825; + this.match(ApexParser.FIELDS); + } + } + catch (re) { + if (re instanceof antlr.RecognitionException) { + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return localContext; + } + public fieldSpecList(): FieldSpecListContext { + const localContext = new FieldSpecListContext(this.context, this.state); + this.enterRule(localContext, 270, ApexParser.RULE_fieldSpecList); + try { + let alternative: number; + this.enterOuterAlt(localContext, 1); + { + this.state = 1827; + this.fieldSpec(); + this.state = 1832; + this.errorHandler.sync(this); + alternative = this.interpreter.adaptivePredict(this.tokenStream, 178, this.context); + while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) { + if (alternative === 1) { + { + { + this.state = 1828; + this.match(ApexParser.COMMA); + this.state = 1829; + this.fieldSpecList(); + } + } + } + this.state = 1834; + this.errorHandler.sync(this); + alternative = this.interpreter.adaptivePredict(this.tokenStream, 178, this.context); + } + } + } + catch (re) { + if (re instanceof antlr.RecognitionException) { + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return localContext; + } + public fieldSpec(): FieldSpecContext { + const localContext = new FieldSpecContext(this.context, this.state); + this.enterRule(localContext, 272, ApexParser.RULE_fieldSpec); + let _la: number; + try { + this.enterOuterAlt(localContext, 1); + { + this.state = 1835; + this.soslId(); + this.state = 1861; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 198) { + { + this.state = 1836; + this.match(ApexParser.LPAREN); + this.state = 1837; + this.fieldList(); + this.state = 1840; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 65) { + { + this.state = 1838; + this.match(ApexParser.WHERE); + this.state = 1839; + this.logicalExpression(); + } + } + + this.state = 1846; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 63) { + { + this.state = 1842; + this.match(ApexParser.USING); + this.state = 1843; + this.match(ApexParser.LISTVIEW); + this.state = 1844; + this.match(ApexParser.ASSIGN); + this.state = 1845; + this.soslId(); + } + } + + this.state = 1851; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 66) { + { + this.state = 1848; + this.match(ApexParser.ORDER); + this.state = 1849; + this.match(ApexParser.BY); + this.state = 1850; + this.fieldOrderList(); + } + } + + this.state = 1854; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 68) { + { + this.state = 1853; + this.limitClause(); + } + } + + this.state = 1857; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 96) { + { + this.state = 1856; + this.offsetClause(); + } + } + + this.state = 1859; + this.match(ApexParser.RPAREN); + } + } + + } + } + catch (re) { + if (re instanceof antlr.RecognitionException) { + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return localContext; + } + public fieldList(): FieldListContext { + const localContext = new FieldListContext(this.context, this.state); + this.enterRule(localContext, 274, ApexParser.RULE_fieldList); + try { + let alternative: number; + this.enterOuterAlt(localContext, 1); + { + this.state = 1863; + this.soslId(); + this.state = 1868; + this.errorHandler.sync(this); + alternative = this.interpreter.adaptivePredict(this.tokenStream, 185, this.context); + while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) { + if (alternative === 1) { + { + { + this.state = 1864; + this.match(ApexParser.COMMA); + this.state = 1865; + this.fieldList(); + } + } + } + this.state = 1870; + this.errorHandler.sync(this); + alternative = this.interpreter.adaptivePredict(this.tokenStream, 185, this.context); + } + } + } + catch (re) { + if (re instanceof antlr.RecognitionException) { + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return localContext; + } + public updateList(): UpdateListContext { + const localContext = new UpdateListContext(this.context, this.state); + this.enterRule(localContext, 276, ApexParser.RULE_updateList); + let _la: number; + try { + this.enterOuterAlt(localContext, 1); + { + this.state = 1871; + this.updateType(); + this.state = 1874; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 205) { + { + this.state = 1872; + this.match(ApexParser.COMMA); + this.state = 1873; + this.updateList(); + } + } + + } + } + catch (re) { + if (re instanceof antlr.RecognitionException) { + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return localContext; + } + public updateType(): UpdateTypeContext { + const localContext = new UpdateTypeContext(this.context, this.state); + this.enterRule(localContext, 278, ApexParser.RULE_updateType); + let _la: number; + try { + this.enterOuterAlt(localContext, 1); + { + this.state = 1876; + _la = this.tokenStream.LA(1); + if(!(_la === 109 || _la === 110)) { + this.errorHandler.recoverInline(this); + } + else { + this.errorHandler.reportMatch(this); + this.consume(); + } + } + } + catch (re) { + if (re instanceof antlr.RecognitionException) { + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return localContext; + } + public networkList(): NetworkListContext { + const localContext = new NetworkListContext(this.context, this.state); + this.enterRule(localContext, 280, ApexParser.RULE_networkList); + let _la: number; + try { + this.enterOuterAlt(localContext, 1); + { + this.state = 1878; + this.match(ApexParser.StringLiteral); + this.state = 1881; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 205) { + { + this.state = 1879; + this.match(ApexParser.COMMA); + this.state = 1880; + this.networkList(); + } + } + + } + } + catch (re) { + if (re instanceof antlr.RecognitionException) { + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return localContext; + } + public soslId(): SoslIdContext { + const localContext = new SoslIdContext(this.context, this.state); + this.enterRule(localContext, 282, ApexParser.RULE_soslId); + try { + let alternative: number; + this.enterOuterAlt(localContext, 1); + { + this.state = 1883; + this.id(); + this.state = 1888; + this.errorHandler.sync(this); + alternative = this.interpreter.adaptivePredict(this.tokenStream, 188, this.context); + while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) { + if (alternative === 1) { + { + { + this.state = 1884; + this.match(ApexParser.DOT); + this.state = 1885; + this.soslId(); + } + } + } + this.state = 1890; + this.errorHandler.sync(this); + alternative = this.interpreter.adaptivePredict(this.tokenStream, 188, this.context); + } + } + } + catch (re) { + if (re instanceof antlr.RecognitionException) { + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return localContext; + } + public id(): IdContext { + const localContext = new IdContext(this.context, this.state); + this.enterRule(localContext, 284, ApexParser.RULE_id); + let _la: number; + try { + this.enterOuterAlt(localContext, 1); + { + this.state = 1891; + _la = this.tokenStream.LA(1); + if(!((((_la) & ~0x1F) === 0 && ((1 << _la) & 5308428) !== 0) || ((((_la - 34)) & ~0x1F) === 0 && ((1 << (_la - 34)) & 4288283411) !== 0) || ((((_la - 66)) & ~0x1F) === 0 && ((1 << (_la - 66)) & 4294967295) !== 0) || ((((_la - 98)) & ~0x1F) === 0 && ((1 << (_la - 98)) & 4294967295) !== 0) || ((((_la - 130)) & ~0x1F) === 0 && ((1 << (_la - 130)) & 4294967295) !== 0) || ((((_la - 162)) & ~0x1F) === 0 && ((1 << (_la - 162)) & 268429311) !== 0) || _la === 244)) { + this.errorHandler.recoverInline(this); + } + else { + this.errorHandler.reportMatch(this); + this.consume(); + } + } + } + catch (re) { + if (re instanceof antlr.RecognitionException) { + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return localContext; + } + public anyId(): AnyIdContext { + const localContext = new AnyIdContext(this.context, this.state); + this.enterRule(localContext, 286, ApexParser.RULE_anyId); + let _la: number; + try { + this.enterOuterAlt(localContext, 1); + { + this.state = 1893; + _la = this.tokenStream.LA(1); + if(!((((_la) & ~0x1F) === 0 && ((1 << _la) & 4294967294) !== 0) || ((((_la - 32)) & ~0x1F) === 0 && ((1 << (_la - 32)) & 4294836221) !== 0) || ((((_la - 64)) & ~0x1F) === 0 && ((1 << (_la - 64)) & 4294967295) !== 0) || ((((_la - 96)) & ~0x1F) === 0 && ((1 << (_la - 96)) & 4294967295) !== 0) || ((((_la - 128)) & ~0x1F) === 0 && ((1 << (_la - 128)) & 4294967295) !== 0) || ((((_la - 160)) & ~0x1F) === 0 && ((1 << (_la - 160)) & 1073717247) !== 0) || _la === 244)) { + this.errorHandler.recoverInline(this); + } + else { + this.errorHandler.reportMatch(this); + this.consume(); + } + } + } + catch (re) { + if (re instanceof antlr.RecognitionException) { + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return localContext; + } + + public override sempred(localContext: antlr.ParserRuleContext | null, ruleIndex: number, predIndex: number): boolean { + switch (ruleIndex) { + case 73: + return this.expression_sempred(localContext as ExpressionContext, predIndex); + } + return true; + } + private expression_sempred(localContext: ExpressionContext | null, predIndex: number): boolean { + switch (predIndex) { + case 0: + return this.precpred(this.context, 14); + case 1: + return this.precpred(this.context, 13); + case 2: + return this.precpred(this.context, 12); + case 3: + return this.precpred(this.context, 11); + case 4: + return this.precpred(this.context, 9); + case 5: + return this.precpred(this.context, 8); + case 6: + return this.precpred(this.context, 7); + case 7: + return this.precpred(this.context, 6); + case 8: + return this.precpred(this.context, 5); + case 9: + return this.precpred(this.context, 4); + case 10: + return this.precpred(this.context, 3); + case 11: + return this.precpred(this.context, 2); + case 12: + return this.precpred(this.context, 1); + case 13: + return this.precpred(this.context, 23); + case 14: + return this.precpred(this.context, 22); + case 15: + return this.precpred(this.context, 17); + case 16: + return this.precpred(this.context, 10); + } + return true; + } + + public static readonly _serializedATN: number[] = [ + 4,1,248,1896,2,0,7,0,2,1,7,1,2,2,7,2,2,3,7,3,2,4,7,4,2,5,7,5,2,6, + 7,6,2,7,7,7,2,8,7,8,2,9,7,9,2,10,7,10,2,11,7,11,2,12,7,12,2,13,7, + 13,2,14,7,14,2,15,7,15,2,16,7,16,2,17,7,17,2,18,7,18,2,19,7,19,2, + 20,7,20,2,21,7,21,2,22,7,22,2,23,7,23,2,24,7,24,2,25,7,25,2,26,7, + 26,2,27,7,27,2,28,7,28,2,29,7,29,2,30,7,30,2,31,7,31,2,32,7,32,2, + 33,7,33,2,34,7,34,2,35,7,35,2,36,7,36,2,37,7,37,2,38,7,38,2,39,7, + 39,2,40,7,40,2,41,7,41,2,42,7,42,2,43,7,43,2,44,7,44,2,45,7,45,2, + 46,7,46,2,47,7,47,2,48,7,48,2,49,7,49,2,50,7,50,2,51,7,51,2,52,7, + 52,2,53,7,53,2,54,7,54,2,55,7,55,2,56,7,56,2,57,7,57,2,58,7,58,2, + 59,7,59,2,60,7,60,2,61,7,61,2,62,7,62,2,63,7,63,2,64,7,64,2,65,7, + 65,2,66,7,66,2,67,7,67,2,68,7,68,2,69,7,69,2,70,7,70,2,71,7,71,2, + 72,7,72,2,73,7,73,2,74,7,74,2,75,7,75,2,76,7,76,2,77,7,77,2,78,7, + 78,2,79,7,79,2,80,7,80,2,81,7,81,2,82,7,82,2,83,7,83,2,84,7,84,2, + 85,7,85,2,86,7,86,2,87,7,87,2,88,7,88,2,89,7,89,2,90,7,90,2,91,7, + 91,2,92,7,92,2,93,7,93,2,94,7,94,2,95,7,95,2,96,7,96,2,97,7,97,2, + 98,7,98,2,99,7,99,2,100,7,100,2,101,7,101,2,102,7,102,2,103,7,103, + 2,104,7,104,2,105,7,105,2,106,7,106,2,107,7,107,2,108,7,108,2,109, + 7,109,2,110,7,110,2,111,7,111,2,112,7,112,2,113,7,113,2,114,7,114, + 2,115,7,115,2,116,7,116,2,117,7,117,2,118,7,118,2,119,7,119,2,120, + 7,120,2,121,7,121,2,122,7,122,2,123,7,123,2,124,7,124,2,125,7,125, + 2,126,7,126,2,127,7,127,2,128,7,128,2,129,7,129,2,130,7,130,2,131, + 7,131,2,132,7,132,2,133,7,133,2,134,7,134,2,135,7,135,2,136,7,136, + 2,137,7,137,2,138,7,138,2,139,7,139,2,140,7,140,2,141,7,141,2,142, + 7,142,2,143,7,143,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,5,0,297,8,0,10, + 0,12,0,300,9,0,1,0,1,0,1,0,1,0,1,1,1,1,1,1,1,2,5,2,310,8,2,10,2, + 12,2,313,9,2,1,2,1,2,1,3,5,3,318,8,3,10,3,12,3,321,9,3,1,3,1,3,5, + 3,325,8,3,10,3,12,3,328,9,3,1,3,1,3,5,3,332,8,3,10,3,12,3,335,9, + 3,1,3,3,3,338,8,3,1,4,1,4,1,4,1,4,3,4,344,8,4,1,4,1,4,3,4,348,8, + 4,1,4,1,4,1,5,1,5,1,5,1,5,3,5,356,8,5,1,5,1,5,1,6,1,6,1,6,5,6,363, + 8,6,10,6,12,6,366,9,6,1,7,1,7,1,7,1,7,3,7,372,8,7,1,7,1,7,1,8,1, + 8,1,8,5,8,379,8,8,10,8,12,8,382,9,8,1,9,1,9,5,9,386,8,9,10,9,12, + 9,389,9,9,1,9,1,9,1,10,1,10,5,10,395,8,10,10,10,12,10,398,9,10,1, + 10,1,10,1,11,1,11,3,11,404,8,11,1,11,1,11,5,11,408,8,11,10,11,12, + 11,411,9,11,1,11,3,11,414,8,11,1,12,1,12,1,12,1,12,1,12,1,12,1,12, + 1,12,1,12,1,12,1,12,1,12,1,12,1,12,1,12,1,12,1,12,1,12,1,12,3,12, + 435,8,12,1,13,1,13,1,13,1,13,1,13,1,13,1,13,3,13,444,8,13,1,14,1, + 14,3,14,448,8,14,1,14,1,14,1,14,1,14,3,14,454,8,14,1,15,1,15,1,15, + 1,15,1,16,1,16,1,16,1,16,1,17,1,17,1,17,1,17,5,17,468,8,17,10,17, + 12,17,471,9,17,1,17,1,17,1,18,5,18,476,8,18,10,18,12,18,479,9,18, + 1,18,1,18,3,18,483,8,18,1,18,1,18,1,18,1,18,1,19,1,19,1,19,5,19, + 492,8,19,10,19,12,19,495,9,19,1,20,1,20,1,20,3,20,500,8,20,1,21, + 1,21,1,21,1,21,5,21,506,8,21,10,21,12,21,509,9,21,1,21,3,21,512, + 8,21,3,21,514,8,21,1,21,1,21,1,22,1,22,1,22,5,22,521,8,22,10,22, + 12,22,524,9,22,1,22,1,22,1,23,1,23,5,23,530,8,23,10,23,12,23,533, + 9,23,1,24,1,24,3,24,537,8,24,1,24,1,24,3,24,541,8,24,1,24,1,24,3, + 24,545,8,24,1,24,1,24,3,24,549,8,24,3,24,551,8,24,1,25,1,25,1,25, + 1,25,1,26,1,26,3,26,559,8,26,1,26,1,26,1,27,1,27,1,27,5,27,566,8, + 27,10,27,12,27,569,9,27,1,28,5,28,572,8,28,10,28,12,28,575,9,28, + 1,28,1,28,1,28,1,29,1,29,1,29,5,29,583,8,29,10,29,12,29,586,9,29, + 1,30,1,30,1,31,1,31,1,31,1,31,1,31,3,31,595,8,31,1,31,3,31,598,8, + 31,1,32,1,32,3,32,602,8,32,1,32,5,32,605,8,32,10,32,12,32,608,9, + 32,1,33,1,33,1,33,1,33,1,34,1,34,1,34,3,34,617,8,34,1,35,1,35,1, + 35,1,35,5,35,623,8,35,10,35,12,35,626,9,35,3,35,628,8,35,1,35,3, + 35,631,8,35,1,35,1,35,1,36,1,36,5,36,637,8,36,10,36,12,36,640,9, + 36,1,36,1,36,1,37,1,37,1,37,1,38,5,38,648,8,38,10,38,12,38,651,9, + 38,1,38,1,38,1,38,1,39,1,39,1,39,1,39,1,39,1,39,1,39,1,39,1,39,1, + 39,1,39,1,39,1,39,1,39,1,39,1,39,1,39,1,39,1,39,1,39,3,39,676,8, + 39,1,40,1,40,1,40,1,40,1,40,3,40,683,8,40,1,41,1,41,1,41,1,41,1, + 41,4,41,690,8,41,11,41,12,41,691,1,41,1,41,1,42,1,42,1,42,1,42,1, + 43,1,43,1,43,1,43,5,43,704,8,43,10,43,12,43,707,9,43,1,43,1,43,1, + 43,3,43,712,8,43,1,44,3,44,715,8,44,1,44,1,44,1,44,1,44,1,44,1,44, + 1,44,1,44,1,44,3,44,726,8,44,1,45,1,45,1,45,1,45,1,45,1,45,3,45, + 734,8,45,1,46,1,46,1,46,1,46,3,46,740,8,46,1,47,1,47,1,47,1,47,1, + 47,1,47,1,48,1,48,1,48,4,48,751,8,48,11,48,12,48,752,1,48,3,48,756, + 8,48,1,48,3,48,759,8,48,1,49,1,49,3,49,763,8,49,1,49,1,49,1,50,1, + 50,1,50,1,50,1,51,1,51,1,51,1,52,1,52,1,52,1,53,1,53,1,53,1,54,1, + 54,3,54,782,8,54,1,54,1,54,1,54,1,55,1,55,3,55,789,8,55,1,55,1,55, + 1,55,1,56,1,56,3,56,796,8,56,1,56,1,56,1,56,1,57,1,57,3,57,803,8, + 57,1,57,1,57,1,57,1,58,1,58,3,58,810,8,58,1,58,1,58,3,58,814,8,58, + 1,58,1,58,1,59,1,59,3,59,820,8,59,1,59,1,59,1,59,1,59,1,60,1,60, + 1,60,3,60,829,8,60,1,60,1,60,1,60,1,61,1,61,1,61,1,62,5,62,838,8, + 62,10,62,12,62,841,9,62,1,62,1,62,3,62,845,8,62,1,63,1,63,1,63,3, + 63,850,8,63,1,64,1,64,1,64,3,64,855,8,64,1,65,1,65,1,65,5,65,860, + 8,65,10,65,12,65,863,9,65,1,65,1,65,1,65,1,65,1,65,1,66,1,66,1,66, + 1,67,1,67,3,67,875,8,67,1,67,1,67,3,67,879,8,67,1,67,1,67,3,67,883, + 8,67,3,67,885,8,67,1,68,1,68,3,68,889,8,68,1,69,1,69,1,69,1,69,1, + 69,1,70,1,70,1,71,1,71,1,71,1,71,1,72,1,72,1,72,5,72,905,8,72,10, + 72,12,72,908,9,72,1,73,1,73,1,73,1,73,1,73,1,73,1,73,1,73,1,73,1, + 73,1,73,1,73,1,73,1,73,1,73,1,73,1,73,1,73,3,73,928,8,73,1,73,1, + 73,1,73,1,73,1,73,1,73,1,73,1,73,1,73,1,73,1,73,1,73,1,73,1,73,3, + 73,944,8,73,1,73,1,73,1,73,1,73,3,73,950,8,73,1,73,1,73,1,73,1,73, + 1,73,1,73,1,73,1,73,1,73,1,73,1,73,1,73,1,73,1,73,1,73,1,73,1,73, + 1,73,1,73,1,73,1,73,1,73,1,73,1,73,1,73,1,73,1,73,1,73,1,73,1,73, + 1,73,1,73,1,73,1,73,1,73,3,73,987,8,73,1,73,1,73,1,73,1,73,1,73, + 1,73,1,73,1,73,1,73,1,73,5,73,999,8,73,10,73,12,73,1002,9,73,1,74, + 1,74,1,74,1,74,1,74,1,74,1,74,1,74,1,74,1,74,1,74,1,74,1,74,3,74, + 1017,8,74,1,75,1,75,1,75,3,75,1022,8,75,1,75,1,75,1,75,1,75,1,75, + 3,75,1029,8,75,1,75,1,75,1,75,1,75,3,75,1035,8,75,1,75,3,75,1038, + 8,75,1,76,1,76,1,76,3,76,1043,8,76,1,76,1,76,1,77,1,77,1,77,1,77, + 1,77,1,77,3,77,1053,8,77,1,78,1,78,1,78,5,78,1058,8,78,10,78,12, + 78,1061,9,78,1,79,1,79,1,79,1,79,1,79,3,79,1068,8,79,1,80,1,80,1, + 80,1,81,1,81,1,82,1,82,1,82,1,82,1,82,1,82,1,82,3,82,1082,8,82,3, + 82,1084,8,82,1,83,1,83,1,83,1,83,5,83,1090,8,83,10,83,12,83,1093, + 9,83,1,83,1,83,1,84,1,84,1,84,1,84,1,85,1,85,1,85,1,85,5,85,1105, + 8,85,10,85,12,85,1108,9,85,1,85,1,85,1,86,1,86,3,86,1114,8,86,1, + 86,1,86,1,87,1,87,1,87,1,87,1,88,1,88,1,88,1,88,1,88,3,88,1127,8, + 88,1,88,3,88,1130,8,88,1,88,3,88,1133,8,88,1,88,3,88,1136,8,88,1, + 88,3,88,1139,8,88,1,88,3,88,1142,8,88,1,88,3,88,1145,8,88,1,88,3, + 88,1148,8,88,1,88,1,88,1,88,3,88,1153,8,88,1,89,1,89,1,89,1,89,1, + 89,3,89,1160,8,89,1,89,3,89,1163,8,89,1,89,3,89,1166,8,89,1,89,1, + 89,1,89,3,89,1171,8,89,1,90,1,90,1,90,5,90,1176,8,90,10,90,12,90, + 1179,9,90,1,91,1,91,3,91,1183,8,91,1,91,1,91,3,91,1187,8,91,1,91, + 1,91,1,91,1,91,3,91,1193,8,91,1,91,3,91,1196,8,91,1,92,1,92,1,92, + 5,92,1201,8,92,10,92,12,92,1204,9,92,1,93,1,93,3,93,1208,8,93,1, + 93,1,93,1,93,3,93,1213,8,93,5,93,1215,8,93,10,93,12,93,1218,9,93, + 1,94,1,94,1,94,5,94,1223,8,94,10,94,12,94,1226,9,94,1,95,1,95,3, + 95,1230,8,95,1,95,1,95,3,95,1234,8,95,1,95,3,95,1237,8,95,1,96,1, + 96,1,97,1,97,1,97,1,97,1,97,1,97,1,97,1,97,1,97,1,97,1,97,1,97,1, + 97,1,97,1,97,1,97,1,97,1,97,1,97,1,97,1,97,1,97,1,97,1,97,1,97,1, + 97,1,97,1,97,1,97,1,97,1,97,1,97,1,97,1,97,1,97,1,97,1,97,1,97,1, + 97,1,97,1,97,1,97,1,97,1,97,1,97,1,97,1,97,1,97,1,97,1,97,1,97,1, + 97,1,97,1,97,1,97,1,97,1,97,1,97,1,97,1,97,1,97,1,97,1,97,1,97,1, + 97,1,97,1,97,1,97,1,97,1,97,1,97,1,97,1,97,1,97,1,97,1,97,1,97,1, + 97,1,97,1,97,1,97,1,97,1,97,1,97,1,97,1,97,1,97,1,97,1,97,1,97,1, + 97,1,97,1,97,1,97,1,97,1,97,1,97,1,97,1,97,1,97,1,97,1,97,1,97,1, + 97,1,97,1,97,1,97,1,97,1,97,1,97,1,97,1,97,1,97,1,97,1,97,1,97,1, + 97,1,97,1,97,1,97,1,97,1,97,3,97,1363,8,97,1,98,1,98,1,98,1,98,1, + 98,1,98,3,98,1371,8,98,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1, + 99,3,99,1382,8,99,1,100,1,100,3,100,1386,8,100,1,101,1,101,1,101, + 4,101,1391,8,101,11,101,12,101,1392,1,101,3,101,1396,8,101,1,101, + 1,101,1,102,1,102,1,102,1,102,1,102,1,103,1,103,1,103,1,104,1,104, + 1,104,5,104,1411,8,104,10,104,12,104,1414,9,104,1,105,1,105,1,105, + 1,105,1,106,1,106,1,106,1,107,1,107,1,107,5,107,1426,8,107,10,107, + 12,107,1429,9,107,1,107,1,107,1,107,5,107,1434,8,107,10,107,12,107, + 1437,9,107,1,107,1,107,3,107,1441,8,107,1,108,1,108,1,108,1,108, + 1,108,3,108,1448,8,108,1,109,1,109,1,109,1,109,1,109,1,109,1,109, + 1,109,3,109,1458,8,109,1,110,1,110,1,110,1,110,1,110,1,110,1,110, + 1,110,1,110,1,110,1,110,1,110,1,110,1,110,1,110,3,110,1475,8,110, + 1,111,1,111,1,111,1,111,1,111,1,111,1,111,1,111,1,111,1,111,3,111, + 1487,8,111,3,111,1489,8,111,1,111,1,111,1,111,1,111,1,111,1,111, + 3,111,1497,8,111,1,112,1,112,1,112,1,112,5,112,1503,8,112,10,112, + 12,112,1506,9,112,1,112,1,112,1,113,3,113,1511,8,113,1,113,1,113, + 1,114,1,114,1,114,1,114,1,114,1,114,1,114,1,114,1,114,1,114,1,114, + 1,114,3,114,1527,8,114,1,115,1,115,1,115,5,115,1532,8,115,10,115, + 12,115,1535,9,115,1,116,1,116,1,116,1,116,1,117,1,117,1,117,1,117, + 1,117,5,117,1546,8,117,10,117,12,117,1549,9,117,1,117,1,117,3,117, + 1553,8,117,1,118,1,118,1,119,1,119,1,119,1,119,1,119,3,119,1562, + 8,119,1,119,1,119,1,119,1,119,1,119,1,119,1,119,5,119,1571,8,119, + 10,119,12,119,1574,9,119,1,119,1,119,1,119,1,119,1,119,1,119,1,119, + 1,119,1,119,5,119,1585,8,119,10,119,12,119,1588,9,119,1,119,1,119, + 3,119,1592,8,119,1,120,1,120,1,120,1,120,1,121,1,121,1,121,5,121, + 1601,8,121,10,121,12,121,1604,9,121,1,122,1,122,3,122,1608,8,122, + 1,122,1,122,3,122,1612,8,122,1,122,1,122,3,122,1616,8,122,1,122, + 1,122,3,122,1620,8,122,3,122,1622,8,122,1,123,1,123,1,123,1,123, + 3,123,1628,8,123,1,124,1,124,1,124,1,124,3,124,1634,8,124,1,125, + 1,125,1,125,1,126,1,126,5,126,1641,8,126,10,126,12,126,1644,9,126, + 1,127,1,127,1,127,1,128,1,128,1,128,1,128,1,128,1,128,1,128,1,128, + 1,128,1,128,1,128,1,128,1,128,1,128,1,128,1,128,1,128,1,128,1,128, + 1,128,1,128,1,128,1,128,1,128,1,128,1,128,1,128,1,128,1,128,1,128, + 1,128,1,128,1,128,1,128,1,128,1,128,1,128,1,128,1,128,1,128,1,128, + 1,128,1,128,1,128,1,128,1,128,1,128,1,128,1,128,1,128,1,128,1,128, + 1,128,1,128,1,128,1,128,1,128,1,128,1,128,1,128,1,128,1,128,1,128, + 1,128,1,128,1,128,1,128,1,128,1,128,1,128,1,128,1,128,1,128,1,128, + 1,128,1,128,1,128,1,128,1,128,1,128,1,128,1,128,1,128,1,128,1,128, + 1,128,3,128,1735,8,128,1,129,3,129,1738,8,129,1,129,1,129,1,130, + 1,130,1,131,1,131,1,131,1,131,1,131,1,131,1,131,1,131,1,131,1,131, + 3,131,1754,8,131,1,132,1,132,1,132,1,132,1,133,1,133,3,133,1762, + 8,133,1,133,1,133,3,133,1766,8,133,1,133,1,133,1,133,1,133,3,133, + 1772,8,133,1,133,1,133,1,133,1,133,3,133,1778,8,133,1,133,1,133, + 1,133,1,133,1,133,1,133,1,133,3,133,1787,8,133,3,133,1789,8,133, + 1,133,1,133,1,133,1,133,1,133,1,133,1,133,3,133,1798,8,133,1,133, + 1,133,1,133,1,133,3,133,1804,8,133,1,133,1,133,1,133,1,133,3,133, + 1810,8,133,1,133,1,133,1,133,1,133,3,133,1816,8,133,1,133,3,133, + 1819,8,133,1,133,1,133,3,133,1823,8,133,1,134,1,134,1,134,1,135, + 1,135,1,135,5,135,1831,8,135,10,135,12,135,1834,9,135,1,136,1,136, + 1,136,1,136,1,136,3,136,1841,8,136,1,136,1,136,1,136,1,136,3,136, + 1847,8,136,1,136,1,136,1,136,3,136,1852,8,136,1,136,3,136,1855,8, + 136,1,136,3,136,1858,8,136,1,136,1,136,3,136,1862,8,136,1,137,1, + 137,1,137,5,137,1867,8,137,10,137,12,137,1870,9,137,1,138,1,138, + 1,138,3,138,1875,8,138,1,139,1,139,1,140,1,140,1,140,3,140,1882, + 8,140,1,141,1,141,1,141,5,141,1887,8,141,10,141,12,141,1890,9,141, + 1,142,1,142,1,143,1,143,1,143,0,1,146,144,0,2,4,6,8,10,12,14,16, + 18,20,22,24,26,28,30,32,34,36,38,40,42,44,46,48,50,52,54,56,58,60, + 62,64,66,68,70,72,74,76,78,80,82,84,86,88,90,92,94,96,98,100,102, + 104,106,108,110,112,114,116,118,120,122,124,126,128,130,132,134, + 136,138,140,142,144,146,148,150,152,154,156,158,160,162,164,166, + 168,170,172,174,176,178,180,182,184,186,188,190,192,194,196,198, + 200,202,204,206,208,210,212,214,216,218,220,222,224,226,228,230, + 232,234,236,238,240,242,244,246,248,250,252,254,256,258,260,262, + 264,266,268,270,272,274,276,278,280,282,284,286,0,23,1,0,2,3,3,0, + 8,8,21,21,45,46,2,0,26,26,192,196,1,0,57,58,1,0,223,226,1,0,210, + 211,1,0,227,228,1,0,225,226,1,0,208,209,1,0,216,220,2,0,207,207, + 233,242,2,0,206,206,212,212,1,0,223,224,2,0,90,90,111,112,2,0,192, + 192,194,194,1,0,99,102,1,0,84,85,1,0,87,88,3,0,46,46,92,92,106,106, + 2,0,90,90,177,180,1,0,109,110,12,0,2,3,16,16,20,20,22,22,34,35,38, + 38,42,43,51,51,53,54,57,172,175,189,244,244,5,0,1,32,34,48,50,172, + 175,189,244,244,2111,0,288,1,0,0,0,2,305,1,0,0,0,4,311,1,0,0,0,6, + 337,1,0,0,0,8,339,1,0,0,0,10,351,1,0,0,0,12,359,1,0,0,0,14,367,1, + 0,0,0,16,375,1,0,0,0,18,383,1,0,0,0,20,392,1,0,0,0,22,413,1,0,0, + 0,24,434,1,0,0,0,26,443,1,0,0,0,28,447,1,0,0,0,30,455,1,0,0,0,32, + 459,1,0,0,0,34,463,1,0,0,0,36,477,1,0,0,0,38,488,1,0,0,0,40,496, + 1,0,0,0,42,501,1,0,0,0,44,517,1,0,0,0,46,531,1,0,0,0,48,550,1,0, + 0,0,50,552,1,0,0,0,52,556,1,0,0,0,54,562,1,0,0,0,56,573,1,0,0,0, + 58,579,1,0,0,0,60,587,1,0,0,0,62,589,1,0,0,0,64,599,1,0,0,0,66,609, + 1,0,0,0,68,616,1,0,0,0,70,618,1,0,0,0,72,634,1,0,0,0,74,643,1,0, + 0,0,76,649,1,0,0,0,78,675,1,0,0,0,80,677,1,0,0,0,82,684,1,0,0,0, + 84,695,1,0,0,0,86,711,1,0,0,0,88,725,1,0,0,0,90,727,1,0,0,0,92,735, + 1,0,0,0,94,741,1,0,0,0,96,747,1,0,0,0,98,760,1,0,0,0,100,766,1,0, + 0,0,102,770,1,0,0,0,104,773,1,0,0,0,106,776,1,0,0,0,108,779,1,0, + 0,0,110,786,1,0,0,0,112,793,1,0,0,0,114,800,1,0,0,0,116,807,1,0, + 0,0,118,817,1,0,0,0,120,825,1,0,0,0,122,833,1,0,0,0,124,839,1,0, + 0,0,126,846,1,0,0,0,128,851,1,0,0,0,130,856,1,0,0,0,132,869,1,0, + 0,0,134,884,1,0,0,0,136,888,1,0,0,0,138,890,1,0,0,0,140,895,1,0, + 0,0,142,897,1,0,0,0,144,901,1,0,0,0,146,927,1,0,0,0,148,1016,1,0, + 0,0,150,1037,1,0,0,0,152,1039,1,0,0,0,154,1046,1,0,0,0,156,1054, + 1,0,0,0,158,1062,1,0,0,0,160,1069,1,0,0,0,162,1072,1,0,0,0,164,1083, + 1,0,0,0,166,1085,1,0,0,0,168,1096,1,0,0,0,170,1100,1,0,0,0,172,1111, + 1,0,0,0,174,1117,1,0,0,0,176,1121,1,0,0,0,178,1154,1,0,0,0,180,1172, + 1,0,0,0,182,1195,1,0,0,0,184,1197,1,0,0,0,186,1205,1,0,0,0,188,1219, + 1,0,0,0,190,1236,1,0,0,0,192,1238,1,0,0,0,194,1362,1,0,0,0,196,1370, + 1,0,0,0,198,1381,1,0,0,0,200,1385,1,0,0,0,202,1387,1,0,0,0,204,1399, + 1,0,0,0,206,1404,1,0,0,0,208,1407,1,0,0,0,210,1415,1,0,0,0,212,1419, + 1,0,0,0,214,1440,1,0,0,0,216,1447,1,0,0,0,218,1457,1,0,0,0,220,1474, + 1,0,0,0,222,1496,1,0,0,0,224,1498,1,0,0,0,226,1510,1,0,0,0,228,1526, + 1,0,0,0,230,1528,1,0,0,0,232,1536,1,0,0,0,234,1552,1,0,0,0,236,1554, + 1,0,0,0,238,1591,1,0,0,0,240,1593,1,0,0,0,242,1597,1,0,0,0,244,1621, + 1,0,0,0,246,1627,1,0,0,0,248,1633,1,0,0,0,250,1635,1,0,0,0,252,1642, + 1,0,0,0,254,1645,1,0,0,0,256,1734,1,0,0,0,258,1737,1,0,0,0,260,1741, + 1,0,0,0,262,1753,1,0,0,0,264,1755,1,0,0,0,266,1761,1,0,0,0,268,1824, + 1,0,0,0,270,1827,1,0,0,0,272,1835,1,0,0,0,274,1863,1,0,0,0,276,1871, + 1,0,0,0,278,1876,1,0,0,0,280,1878,1,0,0,0,282,1883,1,0,0,0,284,1891, + 1,0,0,0,286,1893,1,0,0,0,288,289,5,43,0,0,289,290,3,284,142,0,290, + 291,5,27,0,0,291,292,3,284,142,0,292,293,5,198,0,0,293,298,3,2,1, + 0,294,295,5,205,0,0,295,297,3,2,1,0,296,294,1,0,0,0,297,300,1,0, + 0,0,298,296,1,0,0,0,298,299,1,0,0,0,299,301,1,0,0,0,300,298,1,0, + 0,0,301,302,5,199,0,0,302,303,3,72,36,0,303,304,5,0,0,1,304,1,1, + 0,0,0,305,306,7,0,0,0,306,307,7,1,0,0,307,3,1,0,0,0,308,310,3,6, + 3,0,309,308,1,0,0,0,310,313,1,0,0,0,311,309,1,0,0,0,311,312,1,0, + 0,0,312,314,1,0,0,0,313,311,1,0,0,0,314,315,5,0,0,1,315,5,1,0,0, + 0,316,318,3,24,12,0,317,316,1,0,0,0,318,321,1,0,0,0,319,317,1,0, + 0,0,319,320,1,0,0,0,320,322,1,0,0,0,321,319,1,0,0,0,322,338,3,8, + 4,0,323,325,3,24,12,0,324,323,1,0,0,0,325,328,1,0,0,0,326,324,1, + 0,0,0,326,327,1,0,0,0,327,329,1,0,0,0,328,326,1,0,0,0,329,338,3, + 10,5,0,330,332,3,24,12,0,331,330,1,0,0,0,332,335,1,0,0,0,333,331, + 1,0,0,0,333,334,1,0,0,0,334,336,1,0,0,0,335,333,1,0,0,0,336,338, + 3,14,7,0,337,319,1,0,0,0,337,326,1,0,0,0,337,333,1,0,0,0,338,7,1, + 0,0,0,339,340,5,6,0,0,340,343,3,284,142,0,341,342,5,12,0,0,342,344, + 3,44,22,0,343,341,1,0,0,0,343,344,1,0,0,0,344,347,1,0,0,0,345,346, + 5,19,0,0,346,348,3,16,8,0,347,345,1,0,0,0,347,348,1,0,0,0,348,349, + 1,0,0,0,349,350,3,18,9,0,350,9,1,0,0,0,351,352,5,11,0,0,352,353, + 3,284,142,0,353,355,5,200,0,0,354,356,3,12,6,0,355,354,1,0,0,0,355, + 356,1,0,0,0,356,357,1,0,0,0,357,358,5,201,0,0,358,11,1,0,0,0,359, + 364,3,284,142,0,360,361,5,205,0,0,361,363,3,284,142,0,362,360,1, + 0,0,0,363,366,1,0,0,0,364,362,1,0,0,0,364,365,1,0,0,0,365,13,1,0, + 0,0,366,364,1,0,0,0,367,368,5,23,0,0,368,371,3,284,142,0,369,370, + 5,12,0,0,370,372,3,16,8,0,371,369,1,0,0,0,371,372,1,0,0,0,372,373, + 1,0,0,0,373,374,3,20,10,0,374,15,1,0,0,0,375,380,3,44,22,0,376,377, + 5,205,0,0,377,379,3,44,22,0,378,376,1,0,0,0,379,382,1,0,0,0,380, + 378,1,0,0,0,380,381,1,0,0,0,381,17,1,0,0,0,382,380,1,0,0,0,383,387, + 5,200,0,0,384,386,3,22,11,0,385,384,1,0,0,0,386,389,1,0,0,0,387, + 385,1,0,0,0,387,388,1,0,0,0,388,390,1,0,0,0,389,387,1,0,0,0,390, + 391,5,201,0,0,391,19,1,0,0,0,392,396,5,200,0,0,393,395,3,36,18,0, + 394,393,1,0,0,0,395,398,1,0,0,0,396,394,1,0,0,0,396,397,1,0,0,0, + 397,399,1,0,0,0,398,396,1,0,0,0,399,400,5,201,0,0,400,21,1,0,0,0, + 401,414,5,204,0,0,402,404,5,36,0,0,403,402,1,0,0,0,403,404,1,0,0, + 0,404,405,1,0,0,0,405,414,3,72,36,0,406,408,3,24,12,0,407,406,1, + 0,0,0,408,411,1,0,0,0,409,407,1,0,0,0,409,410,1,0,0,0,410,412,1, + 0,0,0,411,409,1,0,0,0,412,414,3,26,13,0,413,401,1,0,0,0,413,403, + 1,0,0,0,413,409,1,0,0,0,414,23,1,0,0,0,415,435,3,62,31,0,416,435, + 5,17,0,0,417,435,5,31,0,0,418,435,5,30,0,0,419,435,5,29,0,0,420, + 435,5,42,0,0,421,435,5,36,0,0,422,435,5,1,0,0,423,435,5,13,0,0,424, + 435,5,50,0,0,425,435,5,28,0,0,426,435,5,48,0,0,427,435,5,39,0,0, + 428,429,5,53,0,0,429,435,5,35,0,0,430,431,5,54,0,0,431,435,5,35, + 0,0,432,433,5,20,0,0,433,435,5,35,0,0,434,415,1,0,0,0,434,416,1, + 0,0,0,434,417,1,0,0,0,434,418,1,0,0,0,434,419,1,0,0,0,434,420,1, + 0,0,0,434,421,1,0,0,0,434,422,1,0,0,0,434,423,1,0,0,0,434,424,1, + 0,0,0,434,425,1,0,0,0,434,426,1,0,0,0,434,427,1,0,0,0,434,428,1, + 0,0,0,434,430,1,0,0,0,434,432,1,0,0,0,435,25,1,0,0,0,436,444,3,28, + 14,0,437,444,3,32,16,0,438,444,3,30,15,0,439,444,3,14,7,0,440,444, + 3,8,4,0,441,444,3,10,5,0,442,444,3,34,17,0,443,436,1,0,0,0,443,437, + 1,0,0,0,443,438,1,0,0,0,443,439,1,0,0,0,443,440,1,0,0,0,443,441, + 1,0,0,0,443,442,1,0,0,0,444,27,1,0,0,0,445,448,3,44,22,0,446,448, + 5,49,0,0,447,445,1,0,0,0,447,446,1,0,0,0,448,449,1,0,0,0,449,450, + 3,284,142,0,450,453,3,52,26,0,451,454,3,72,36,0,452,454,5,204,0, + 0,453,451,1,0,0,0,453,452,1,0,0,0,454,29,1,0,0,0,455,456,3,58,29, + 0,456,457,3,52,26,0,457,458,3,72,36,0,458,31,1,0,0,0,459,460,3,44, + 22,0,460,461,3,38,19,0,461,462,5,204,0,0,462,33,1,0,0,0,463,464, + 3,44,22,0,464,465,3,284,142,0,465,469,5,200,0,0,466,468,3,124,62, + 0,467,466,1,0,0,0,468,471,1,0,0,0,469,467,1,0,0,0,469,470,1,0,0, + 0,470,472,1,0,0,0,471,469,1,0,0,0,472,473,5,201,0,0,473,35,1,0,0, + 0,474,476,3,24,12,0,475,474,1,0,0,0,476,479,1,0,0,0,477,475,1,0, + 0,0,477,478,1,0,0,0,478,482,1,0,0,0,479,477,1,0,0,0,480,483,3,44, + 22,0,481,483,5,49,0,0,482,480,1,0,0,0,482,481,1,0,0,0,483,484,1, + 0,0,0,484,485,3,284,142,0,485,486,3,52,26,0,486,487,5,204,0,0,487, + 37,1,0,0,0,488,493,3,40,20,0,489,490,5,205,0,0,490,492,3,40,20,0, + 491,489,1,0,0,0,492,495,1,0,0,0,493,491,1,0,0,0,493,494,1,0,0,0, + 494,39,1,0,0,0,495,493,1,0,0,0,496,499,3,284,142,0,497,498,5,207, + 0,0,498,500,3,146,73,0,499,497,1,0,0,0,499,500,1,0,0,0,500,41,1, + 0,0,0,501,513,5,200,0,0,502,507,3,146,73,0,503,504,5,205,0,0,504, + 506,3,146,73,0,505,503,1,0,0,0,506,509,1,0,0,0,507,505,1,0,0,0,507, + 508,1,0,0,0,508,511,1,0,0,0,509,507,1,0,0,0,510,512,5,205,0,0,511, + 510,1,0,0,0,511,512,1,0,0,0,512,514,1,0,0,0,513,502,1,0,0,0,513, + 514,1,0,0,0,514,515,1,0,0,0,515,516,5,201,0,0,516,43,1,0,0,0,517, + 522,3,48,24,0,518,519,5,206,0,0,519,521,3,48,24,0,520,518,1,0,0, + 0,521,524,1,0,0,0,522,520,1,0,0,0,522,523,1,0,0,0,523,525,1,0,0, + 0,524,522,1,0,0,0,525,526,3,46,23,0,526,45,1,0,0,0,527,528,5,202, + 0,0,528,530,5,203,0,0,529,527,1,0,0,0,530,533,1,0,0,0,531,529,1, + 0,0,0,531,532,1,0,0,0,532,47,1,0,0,0,533,531,1,0,0,0,534,536,5,55, + 0,0,535,537,3,50,25,0,536,535,1,0,0,0,536,537,1,0,0,0,537,551,1, + 0,0,0,538,540,5,34,0,0,539,541,3,50,25,0,540,539,1,0,0,0,540,541, + 1,0,0,0,541,551,1,0,0,0,542,544,5,56,0,0,543,545,3,50,25,0,544,543, + 1,0,0,0,544,545,1,0,0,0,545,551,1,0,0,0,546,548,3,284,142,0,547, + 549,3,50,25,0,548,547,1,0,0,0,548,549,1,0,0,0,549,551,1,0,0,0,550, + 534,1,0,0,0,550,538,1,0,0,0,550,542,1,0,0,0,550,546,1,0,0,0,551, + 49,1,0,0,0,552,553,5,209,0,0,553,554,3,16,8,0,554,555,5,208,0,0, + 555,51,1,0,0,0,556,558,5,198,0,0,557,559,3,54,27,0,558,557,1,0,0, + 0,558,559,1,0,0,0,559,560,1,0,0,0,560,561,5,199,0,0,561,53,1,0,0, + 0,562,567,3,56,28,0,563,564,5,205,0,0,564,566,3,56,28,0,565,563, + 1,0,0,0,566,569,1,0,0,0,567,565,1,0,0,0,567,568,1,0,0,0,568,55,1, + 0,0,0,569,567,1,0,0,0,570,572,3,24,12,0,571,570,1,0,0,0,572,575, + 1,0,0,0,573,571,1,0,0,0,573,574,1,0,0,0,574,576,1,0,0,0,575,573, + 1,0,0,0,576,577,3,44,22,0,577,578,3,284,142,0,578,57,1,0,0,0,579, + 584,3,284,142,0,580,581,5,206,0,0,581,583,3,284,142,0,582,580,1, + 0,0,0,583,586,1,0,0,0,584,582,1,0,0,0,584,585,1,0,0,0,585,59,1,0, + 0,0,586,584,1,0,0,0,587,588,7,2,0,0,588,61,1,0,0,0,589,590,5,243, + 0,0,590,597,3,58,29,0,591,594,5,198,0,0,592,595,3,64,32,0,593,595, + 3,68,34,0,594,592,1,0,0,0,594,593,1,0,0,0,594,595,1,0,0,0,595,596, + 1,0,0,0,596,598,5,199,0,0,597,591,1,0,0,0,597,598,1,0,0,0,598,63, + 1,0,0,0,599,606,3,66,33,0,600,602,5,205,0,0,601,600,1,0,0,0,601, + 602,1,0,0,0,602,603,1,0,0,0,603,605,3,66,33,0,604,601,1,0,0,0,605, + 608,1,0,0,0,606,604,1,0,0,0,606,607,1,0,0,0,607,65,1,0,0,0,608,606, + 1,0,0,0,609,610,3,284,142,0,610,611,5,207,0,0,611,612,3,68,34,0, + 612,67,1,0,0,0,613,617,3,146,73,0,614,617,3,62,31,0,615,617,3,70, + 35,0,616,613,1,0,0,0,616,614,1,0,0,0,616,615,1,0,0,0,617,69,1,0, + 0,0,618,627,5,200,0,0,619,624,3,68,34,0,620,621,5,205,0,0,621,623, + 3,68,34,0,622,620,1,0,0,0,623,626,1,0,0,0,624,622,1,0,0,0,624,625, + 1,0,0,0,625,628,1,0,0,0,626,624,1,0,0,0,627,619,1,0,0,0,627,628, + 1,0,0,0,628,630,1,0,0,0,629,631,5,205,0,0,630,629,1,0,0,0,630,631, + 1,0,0,0,631,632,1,0,0,0,632,633,5,201,0,0,633,71,1,0,0,0,634,638, + 5,200,0,0,635,637,3,78,39,0,636,635,1,0,0,0,637,640,1,0,0,0,638, + 636,1,0,0,0,638,639,1,0,0,0,639,641,1,0,0,0,640,638,1,0,0,0,641, + 642,5,201,0,0,642,73,1,0,0,0,643,644,3,76,38,0,644,645,5,204,0,0, + 645,75,1,0,0,0,646,648,3,24,12,0,647,646,1,0,0,0,648,651,1,0,0,0, + 649,647,1,0,0,0,649,650,1,0,0,0,650,652,1,0,0,0,651,649,1,0,0,0, + 652,653,3,44,22,0,653,654,3,38,19,0,654,77,1,0,0,0,655,676,3,72, + 36,0,656,676,3,80,40,0,657,676,3,82,41,0,658,676,3,90,45,0,659,676, + 3,92,46,0,660,676,3,94,47,0,661,676,3,96,48,0,662,676,3,98,49,0, + 663,676,3,100,50,0,664,676,3,102,51,0,665,676,3,104,52,0,666,676, + 3,108,54,0,667,676,3,110,55,0,668,676,3,112,56,0,669,676,3,114,57, + 0,670,676,3,116,58,0,671,676,3,118,59,0,672,676,3,120,60,0,673,676, + 3,74,37,0,674,676,3,122,61,0,675,655,1,0,0,0,675,656,1,0,0,0,675, + 657,1,0,0,0,675,658,1,0,0,0,675,659,1,0,0,0,675,660,1,0,0,0,675, + 661,1,0,0,0,675,662,1,0,0,0,675,663,1,0,0,0,675,664,1,0,0,0,675, + 665,1,0,0,0,675,666,1,0,0,0,675,667,1,0,0,0,675,668,1,0,0,0,675, + 669,1,0,0,0,675,670,1,0,0,0,675,671,1,0,0,0,675,672,1,0,0,0,675, + 673,1,0,0,0,675,674,1,0,0,0,676,79,1,0,0,0,677,678,5,18,0,0,678, + 679,3,142,71,0,679,682,3,78,39,0,680,681,5,10,0,0,681,683,3,78,39, + 0,682,680,1,0,0,0,682,683,1,0,0,0,683,81,1,0,0,0,684,685,5,38,0, + 0,685,686,5,27,0,0,686,687,3,146,73,0,687,689,5,200,0,0,688,690, + 3,84,42,0,689,688,1,0,0,0,690,691,1,0,0,0,691,689,1,0,0,0,691,692, + 1,0,0,0,692,693,1,0,0,0,693,694,5,201,0,0,694,83,1,0,0,0,695,696, + 5,51,0,0,696,697,3,86,43,0,697,698,3,72,36,0,698,85,1,0,0,0,699, + 712,5,10,0,0,700,705,3,88,44,0,701,702,5,205,0,0,702,704,3,88,44, + 0,703,701,1,0,0,0,704,707,1,0,0,0,705,703,1,0,0,0,705,706,1,0,0, + 0,706,712,1,0,0,0,707,705,1,0,0,0,708,709,3,284,142,0,709,710,3, + 284,142,0,710,712,1,0,0,0,711,699,1,0,0,0,711,700,1,0,0,0,711,708, + 1,0,0,0,712,87,1,0,0,0,713,715,5,226,0,0,714,713,1,0,0,0,714,715, + 1,0,0,0,715,716,1,0,0,0,716,726,5,192,0,0,717,726,5,193,0,0,718, + 726,5,196,0,0,719,726,5,26,0,0,720,726,3,284,142,0,721,722,5,198, + 0,0,722,723,3,88,44,0,723,724,5,199,0,0,724,726,1,0,0,0,725,714, + 1,0,0,0,725,717,1,0,0,0,725,718,1,0,0,0,725,719,1,0,0,0,725,720, + 1,0,0,0,725,721,1,0,0,0,726,89,1,0,0,0,727,728,5,15,0,0,728,729, + 5,198,0,0,729,730,3,134,67,0,730,733,5,199,0,0,731,734,3,78,39,0, + 732,734,5,204,0,0,733,731,1,0,0,0,733,732,1,0,0,0,734,91,1,0,0,0, + 735,736,5,52,0,0,736,739,3,142,71,0,737,740,3,78,39,0,738,740,5, + 204,0,0,739,737,1,0,0,0,739,738,1,0,0,0,740,93,1,0,0,0,741,742,5, + 9,0,0,742,743,3,78,39,0,743,744,5,52,0,0,744,745,3,142,71,0,745, + 746,5,204,0,0,746,95,1,0,0,0,747,748,5,44,0,0,748,758,3,72,36,0, + 749,751,3,130,65,0,750,749,1,0,0,0,751,752,1,0,0,0,752,750,1,0,0, + 0,752,753,1,0,0,0,753,755,1,0,0,0,754,756,3,132,66,0,755,754,1,0, + 0,0,755,756,1,0,0,0,756,759,1,0,0,0,757,759,3,132,66,0,758,750,1, + 0,0,0,758,757,1,0,0,0,759,97,1,0,0,0,760,762,5,32,0,0,761,763,3, + 146,73,0,762,761,1,0,0,0,762,763,1,0,0,0,763,764,1,0,0,0,764,765, + 5,204,0,0,765,99,1,0,0,0,766,767,5,41,0,0,767,768,3,146,73,0,768, + 769,5,204,0,0,769,101,1,0,0,0,770,771,5,4,0,0,771,772,5,204,0,0, + 772,103,1,0,0,0,773,774,5,7,0,0,774,775,5,204,0,0,775,105,1,0,0, + 0,776,777,5,62,0,0,777,778,7,3,0,0,778,107,1,0,0,0,779,781,5,21, + 0,0,780,782,3,106,53,0,781,780,1,0,0,0,781,782,1,0,0,0,782,783,1, + 0,0,0,783,784,3,146,73,0,784,785,5,204,0,0,785,109,1,0,0,0,786,788, + 5,46,0,0,787,789,3,106,53,0,788,787,1,0,0,0,788,789,1,0,0,0,789, + 790,1,0,0,0,790,791,3,146,73,0,791,792,5,204,0,0,792,111,1,0,0,0, + 793,795,5,8,0,0,794,796,3,106,53,0,795,794,1,0,0,0,795,796,1,0,0, + 0,796,797,1,0,0,0,797,798,3,146,73,0,798,799,5,204,0,0,799,113,1, + 0,0,0,800,802,5,45,0,0,801,803,3,106,53,0,802,801,1,0,0,0,802,803, + 1,0,0,0,803,804,1,0,0,0,804,805,3,146,73,0,805,806,5,204,0,0,806, + 115,1,0,0,0,807,809,5,47,0,0,808,810,3,106,53,0,809,808,1,0,0,0, + 809,810,1,0,0,0,810,811,1,0,0,0,811,813,3,146,73,0,812,814,3,58, + 29,0,813,812,1,0,0,0,813,814,1,0,0,0,814,815,1,0,0,0,815,816,5,204, + 0,0,816,117,1,0,0,0,817,819,5,24,0,0,818,820,3,106,53,0,819,818, + 1,0,0,0,819,820,1,0,0,0,820,821,1,0,0,0,821,822,3,146,73,0,822,823, + 3,146,73,0,823,824,5,204,0,0,824,119,1,0,0,0,825,826,5,33,0,0,826, + 828,5,198,0,0,827,829,3,144,72,0,828,827,1,0,0,0,828,829,1,0,0,0, + 829,830,1,0,0,0,830,831,5,199,0,0,831,832,3,72,36,0,832,121,1,0, + 0,0,833,834,3,146,73,0,834,835,5,204,0,0,835,123,1,0,0,0,836,838, + 3,24,12,0,837,836,1,0,0,0,838,841,1,0,0,0,839,837,1,0,0,0,839,840, + 1,0,0,0,840,844,1,0,0,0,841,839,1,0,0,0,842,845,3,126,63,0,843,845, + 3,128,64,0,844,842,1,0,0,0,844,843,1,0,0,0,845,125,1,0,0,0,846,849, + 5,16,0,0,847,850,5,204,0,0,848,850,3,72,36,0,849,847,1,0,0,0,849, + 848,1,0,0,0,850,127,1,0,0,0,851,854,5,34,0,0,852,855,5,204,0,0,853, + 855,3,72,36,0,854,852,1,0,0,0,854,853,1,0,0,0,855,129,1,0,0,0,856, + 857,5,5,0,0,857,861,5,198,0,0,858,860,3,24,12,0,859,858,1,0,0,0, + 860,863,1,0,0,0,861,859,1,0,0,0,861,862,1,0,0,0,862,864,1,0,0,0, + 863,861,1,0,0,0,864,865,3,58,29,0,865,866,3,284,142,0,866,867,5, + 199,0,0,867,868,3,72,36,0,868,131,1,0,0,0,869,870,5,14,0,0,870,871, + 3,72,36,0,871,133,1,0,0,0,872,885,3,138,69,0,873,875,3,136,68,0, + 874,873,1,0,0,0,874,875,1,0,0,0,875,876,1,0,0,0,876,878,5,204,0, + 0,877,879,3,146,73,0,878,877,1,0,0,0,878,879,1,0,0,0,879,880,1,0, + 0,0,880,882,5,204,0,0,881,883,3,140,70,0,882,881,1,0,0,0,882,883, + 1,0,0,0,883,885,1,0,0,0,884,872,1,0,0,0,884,874,1,0,0,0,885,135, + 1,0,0,0,886,889,3,76,38,0,887,889,3,144,72,0,888,886,1,0,0,0,888, + 887,1,0,0,0,889,137,1,0,0,0,890,891,3,44,22,0,891,892,3,284,142, + 0,892,893,5,215,0,0,893,894,3,146,73,0,894,139,1,0,0,0,895,896,3, + 144,72,0,896,141,1,0,0,0,897,898,5,198,0,0,898,899,3,146,73,0,899, + 900,5,199,0,0,900,143,1,0,0,0,901,906,3,146,73,0,902,903,5,205,0, + 0,903,905,3,146,73,0,904,902,1,0,0,0,905,908,1,0,0,0,906,904,1,0, + 0,0,906,907,1,0,0,0,907,145,1,0,0,0,908,906,1,0,0,0,909,910,6,73, + -1,0,910,928,3,148,74,0,911,928,3,150,75,0,912,913,5,25,0,0,913, + 928,3,154,77,0,914,915,5,198,0,0,915,916,3,44,22,0,916,917,5,199, + 0,0,917,918,3,146,73,19,918,928,1,0,0,0,919,920,5,198,0,0,920,921, + 3,146,73,0,921,922,5,199,0,0,922,928,1,0,0,0,923,924,7,4,0,0,924, + 928,3,146,73,16,925,926,7,5,0,0,926,928,3,146,73,15,927,909,1,0, + 0,0,927,911,1,0,0,0,927,912,1,0,0,0,927,914,1,0,0,0,927,919,1,0, + 0,0,927,923,1,0,0,0,927,925,1,0,0,0,928,1000,1,0,0,0,929,930,10, + 14,0,0,930,931,7,6,0,0,931,999,3,146,73,15,932,933,10,13,0,0,933, + 934,7,7,0,0,934,999,3,146,73,14,935,943,10,12,0,0,936,937,5,209, + 0,0,937,944,5,209,0,0,938,939,5,208,0,0,939,940,5,208,0,0,940,944, + 5,208,0,0,941,942,5,208,0,0,942,944,5,208,0,0,943,936,1,0,0,0,943, + 938,1,0,0,0,943,941,1,0,0,0,944,945,1,0,0,0,945,999,3,146,73,13, + 946,947,10,11,0,0,947,949,7,8,0,0,948,950,5,207,0,0,949,948,1,0, + 0,0,949,950,1,0,0,0,950,951,1,0,0,0,951,999,3,146,73,12,952,953, + 10,9,0,0,953,954,7,9,0,0,954,999,3,146,73,10,955,956,10,8,0,0,956, + 957,5,229,0,0,957,999,3,146,73,9,958,959,10,7,0,0,959,960,5,231, + 0,0,960,999,3,146,73,8,961,962,10,6,0,0,962,963,5,230,0,0,963,999, + 3,146,73,7,964,965,10,5,0,0,965,966,5,221,0,0,966,999,3,146,73,6, + 967,968,10,4,0,0,968,969,5,222,0,0,969,999,3,146,73,5,970,971,10, + 3,0,0,971,972,5,213,0,0,972,973,3,146,73,0,973,974,5,215,0,0,974, + 975,3,146,73,3,975,999,1,0,0,0,976,977,10,2,0,0,977,978,5,214,0, + 0,978,999,3,146,73,2,979,980,10,1,0,0,980,981,7,10,0,0,981,999,3, + 146,73,1,982,983,10,23,0,0,983,986,7,11,0,0,984,987,3,152,76,0,985, + 987,3,286,143,0,986,984,1,0,0,0,986,985,1,0,0,0,987,999,1,0,0,0, + 988,989,10,22,0,0,989,990,5,202,0,0,990,991,3,146,73,0,991,992,5, + 203,0,0,992,999,1,0,0,0,993,994,10,17,0,0,994,999,7,12,0,0,995,996, + 10,10,0,0,996,997,5,22,0,0,997,999,3,44,22,0,998,929,1,0,0,0,998, + 932,1,0,0,0,998,935,1,0,0,0,998,946,1,0,0,0,998,952,1,0,0,0,998, + 955,1,0,0,0,998,958,1,0,0,0,998,961,1,0,0,0,998,964,1,0,0,0,998, + 967,1,0,0,0,998,970,1,0,0,0,998,976,1,0,0,0,998,979,1,0,0,0,998, + 982,1,0,0,0,998,988,1,0,0,0,998,993,1,0,0,0,998,995,1,0,0,0,999, + 1002,1,0,0,0,1000,998,1,0,0,0,1000,1001,1,0,0,0,1001,147,1,0,0,0, + 1002,1000,1,0,0,0,1003,1017,5,40,0,0,1004,1017,5,37,0,0,1005,1017, + 3,60,30,0,1006,1007,3,44,22,0,1007,1008,5,206,0,0,1008,1009,5,6, + 0,0,1009,1017,1,0,0,0,1010,1011,5,49,0,0,1011,1012,5,206,0,0,1012, + 1017,5,6,0,0,1013,1017,3,284,142,0,1014,1017,3,174,87,0,1015,1017, + 3,262,131,0,1016,1003,1,0,0,0,1016,1004,1,0,0,0,1016,1005,1,0,0, + 0,1016,1006,1,0,0,0,1016,1010,1,0,0,0,1016,1013,1,0,0,0,1016,1014, + 1,0,0,0,1016,1015,1,0,0,0,1017,149,1,0,0,0,1018,1019,3,284,142,0, + 1019,1021,5,198,0,0,1020,1022,3,144,72,0,1021,1020,1,0,0,0,1021, + 1022,1,0,0,0,1022,1023,1,0,0,0,1023,1024,5,199,0,0,1024,1038,1,0, + 0,0,1025,1026,5,40,0,0,1026,1028,5,198,0,0,1027,1029,3,144,72,0, + 1028,1027,1,0,0,0,1028,1029,1,0,0,0,1029,1030,1,0,0,0,1030,1038, + 5,199,0,0,1031,1032,5,37,0,0,1032,1034,5,198,0,0,1033,1035,3,144, + 72,0,1034,1033,1,0,0,0,1034,1035,1,0,0,0,1035,1036,1,0,0,0,1036, + 1038,5,199,0,0,1037,1018,1,0,0,0,1037,1025,1,0,0,0,1037,1031,1,0, + 0,0,1038,151,1,0,0,0,1039,1040,3,286,143,0,1040,1042,5,198,0,0,1041, + 1043,3,144,72,0,1042,1041,1,0,0,0,1042,1043,1,0,0,0,1043,1044,1, + 0,0,0,1044,1045,5,199,0,0,1045,153,1,0,0,0,1046,1052,3,156,78,0, + 1047,1053,3,160,80,0,1048,1053,3,162,81,0,1049,1053,3,164,82,0,1050, + 1053,3,166,83,0,1051,1053,3,170,85,0,1052,1047,1,0,0,0,1052,1048, + 1,0,0,0,1052,1049,1,0,0,0,1052,1050,1,0,0,0,1052,1051,1,0,0,0,1053, + 155,1,0,0,0,1054,1059,3,158,79,0,1055,1056,5,206,0,0,1056,1058,3, + 158,79,0,1057,1055,1,0,0,0,1058,1061,1,0,0,0,1059,1057,1,0,0,0,1059, + 1060,1,0,0,0,1060,157,1,0,0,0,1061,1059,1,0,0,0,1062,1067,3,286, + 143,0,1063,1064,5,209,0,0,1064,1065,3,16,8,0,1065,1066,5,208,0,0, + 1066,1068,1,0,0,0,1067,1063,1,0,0,0,1067,1068,1,0,0,0,1068,159,1, + 0,0,0,1069,1070,5,200,0,0,1070,1071,5,201,0,0,1071,161,1,0,0,0,1072, + 1073,3,172,86,0,1073,163,1,0,0,0,1074,1075,5,202,0,0,1075,1076,3, + 146,73,0,1076,1077,5,203,0,0,1077,1084,1,0,0,0,1078,1079,5,202,0, + 0,1079,1081,5,203,0,0,1080,1082,3,42,21,0,1081,1080,1,0,0,0,1081, + 1082,1,0,0,0,1082,1084,1,0,0,0,1083,1074,1,0,0,0,1083,1078,1,0,0, + 0,1084,165,1,0,0,0,1085,1086,5,200,0,0,1086,1091,3,168,84,0,1087, + 1088,5,205,0,0,1088,1090,3,168,84,0,1089,1087,1,0,0,0,1090,1093, + 1,0,0,0,1091,1089,1,0,0,0,1091,1092,1,0,0,0,1092,1094,1,0,0,0,1093, + 1091,1,0,0,0,1094,1095,5,201,0,0,1095,167,1,0,0,0,1096,1097,3,146, + 73,0,1097,1098,5,232,0,0,1098,1099,3,146,73,0,1099,169,1,0,0,0,1100, + 1101,5,200,0,0,1101,1106,3,146,73,0,1102,1103,5,205,0,0,1103,1105, + 3,146,73,0,1104,1102,1,0,0,0,1105,1108,1,0,0,0,1106,1104,1,0,0,0, + 1106,1107,1,0,0,0,1107,1109,1,0,0,0,1108,1106,1,0,0,0,1109,1110, + 5,201,0,0,1110,171,1,0,0,0,1111,1113,5,198,0,0,1112,1114,3,144,72, + 0,1113,1112,1,0,0,0,1113,1114,1,0,0,0,1114,1115,1,0,0,0,1115,1116, + 5,199,0,0,1116,173,1,0,0,0,1117,1118,5,202,0,0,1118,1119,3,176,88, + 0,1119,1120,5,203,0,0,1120,175,1,0,0,0,1121,1122,5,59,0,0,1122,1123, + 3,180,90,0,1123,1124,5,61,0,0,1124,1126,3,186,93,0,1125,1127,3,210, + 105,0,1126,1125,1,0,0,0,1126,1127,1,0,0,0,1127,1129,1,0,0,0,1128, + 1130,3,212,106,0,1129,1128,1,0,0,0,1129,1130,1,0,0,0,1130,1132,1, + 0,0,0,1131,1133,3,228,114,0,1132,1131,1,0,0,0,1132,1133,1,0,0,0, + 1133,1135,1,0,0,0,1134,1136,3,238,119,0,1135,1134,1,0,0,0,1135,1136, + 1,0,0,0,1136,1138,1,0,0,0,1137,1139,3,240,120,0,1138,1137,1,0,0, + 0,1138,1139,1,0,0,0,1139,1141,1,0,0,0,1140,1142,3,246,123,0,1141, + 1140,1,0,0,0,1141,1142,1,0,0,0,1142,1144,1,0,0,0,1143,1145,3,248, + 124,0,1144,1143,1,0,0,0,1144,1145,1,0,0,0,1145,1147,1,0,0,0,1146, + 1148,3,250,125,0,1147,1146,1,0,0,0,1147,1148,1,0,0,0,1148,1149,1, + 0,0,0,1149,1152,3,252,126,0,1150,1151,5,46,0,0,1151,1153,3,276,138, + 0,1152,1150,1,0,0,0,1152,1153,1,0,0,0,1153,177,1,0,0,0,1154,1155, + 5,59,0,0,1155,1156,3,188,94,0,1156,1157,5,61,0,0,1157,1159,3,186, + 93,0,1158,1160,3,212,106,0,1159,1158,1,0,0,0,1159,1160,1,0,0,0,1160, + 1162,1,0,0,0,1161,1163,3,240,120,0,1162,1161,1,0,0,0,1162,1163,1, + 0,0,0,1163,1165,1,0,0,0,1164,1166,3,246,123,0,1165,1164,1,0,0,0, + 1165,1166,1,0,0,0,1166,1167,1,0,0,0,1167,1170,3,252,126,0,1168,1169, + 5,46,0,0,1169,1171,3,276,138,0,1170,1168,1,0,0,0,1170,1171,1,0,0, + 0,1171,179,1,0,0,0,1172,1177,3,182,91,0,1173,1174,5,205,0,0,1174, + 1176,3,182,91,0,1175,1173,1,0,0,0,1176,1179,1,0,0,0,1177,1175,1, + 0,0,0,1177,1178,1,0,0,0,1178,181,1,0,0,0,1179,1177,1,0,0,0,1180, + 1182,3,184,92,0,1181,1183,3,260,130,0,1182,1181,1,0,0,0,1182,1183, + 1,0,0,0,1183,1196,1,0,0,0,1184,1186,3,194,97,0,1185,1187,3,260,130, + 0,1186,1185,1,0,0,0,1186,1187,1,0,0,0,1187,1196,1,0,0,0,1188,1189, + 5,198,0,0,1189,1190,3,178,89,0,1190,1192,5,199,0,0,1191,1193,3,260, + 130,0,1192,1191,1,0,0,0,1192,1193,1,0,0,0,1193,1196,1,0,0,0,1194, + 1196,3,202,101,0,1195,1180,1,0,0,0,1195,1184,1,0,0,0,1195,1188,1, + 0,0,0,1195,1194,1,0,0,0,1196,183,1,0,0,0,1197,1202,3,260,130,0,1198, + 1199,5,206,0,0,1199,1201,3,260,130,0,1200,1198,1,0,0,0,1201,1204, + 1,0,0,0,1202,1200,1,0,0,0,1202,1203,1,0,0,0,1203,185,1,0,0,0,1204, + 1202,1,0,0,0,1205,1207,3,184,92,0,1206,1208,3,260,130,0,1207,1206, + 1,0,0,0,1207,1208,1,0,0,0,1208,1216,1,0,0,0,1209,1210,5,205,0,0, + 1210,1212,3,184,92,0,1211,1213,3,260,130,0,1212,1211,1,0,0,0,1212, + 1213,1,0,0,0,1213,1215,1,0,0,0,1214,1209,1,0,0,0,1215,1218,1,0,0, + 0,1216,1214,1,0,0,0,1216,1217,1,0,0,0,1217,187,1,0,0,0,1218,1216, + 1,0,0,0,1219,1224,3,190,95,0,1220,1221,5,205,0,0,1221,1223,3,190, + 95,0,1222,1220,1,0,0,0,1223,1226,1,0,0,0,1224,1222,1,0,0,0,1224, + 1225,1,0,0,0,1225,189,1,0,0,0,1226,1224,1,0,0,0,1227,1229,3,184, + 92,0,1228,1230,3,260,130,0,1229,1228,1,0,0,0,1229,1230,1,0,0,0,1230, + 1237,1,0,0,0,1231,1233,3,194,97,0,1232,1234,3,260,130,0,1233,1232, + 1,0,0,0,1233,1234,1,0,0,0,1234,1237,1,0,0,0,1235,1237,3,202,101, + 0,1236,1227,1,0,0,0,1236,1231,1,0,0,0,1236,1235,1,0,0,0,1237,191, + 1,0,0,0,1238,1239,7,13,0,0,1239,193,1,0,0,0,1240,1241,5,72,0,0,1241, + 1242,5,198,0,0,1242,1243,3,184,92,0,1243,1244,5,199,0,0,1244,1363, + 1,0,0,0,1245,1246,5,60,0,0,1246,1247,5,198,0,0,1247,1363,5,199,0, + 0,1248,1249,5,60,0,0,1249,1250,5,198,0,0,1250,1251,3,184,92,0,1251, + 1252,5,199,0,0,1252,1363,1,0,0,0,1253,1254,5,73,0,0,1254,1255,5, + 198,0,0,1255,1256,3,184,92,0,1256,1257,5,199,0,0,1257,1363,1,0,0, + 0,1258,1259,5,74,0,0,1259,1260,5,198,0,0,1260,1261,3,184,92,0,1261, + 1262,5,199,0,0,1262,1363,1,0,0,0,1263,1264,5,75,0,0,1264,1265,5, + 198,0,0,1265,1266,3,184,92,0,1266,1267,5,199,0,0,1267,1363,1,0,0, + 0,1268,1269,5,76,0,0,1269,1270,5,198,0,0,1270,1271,3,184,92,0,1271, + 1272,5,199,0,0,1272,1363,1,0,0,0,1273,1274,5,95,0,0,1274,1275,5, + 198,0,0,1275,1276,3,184,92,0,1276,1277,5,199,0,0,1277,1363,1,0,0, + 0,1278,1279,5,108,0,0,1279,1280,5,198,0,0,1280,1281,3,184,92,0,1281, + 1282,5,199,0,0,1282,1363,1,0,0,0,1283,1284,5,115,0,0,1284,1285,5, + 198,0,0,1285,1286,3,196,98,0,1286,1287,5,199,0,0,1287,1363,1,0,0, + 0,1288,1289,5,116,0,0,1289,1290,5,198,0,0,1290,1291,3,196,98,0,1291, + 1292,5,199,0,0,1292,1363,1,0,0,0,1293,1294,5,117,0,0,1294,1295,5, + 198,0,0,1295,1296,3,196,98,0,1296,1297,5,199,0,0,1297,1363,1,0,0, + 0,1298,1299,5,118,0,0,1299,1300,5,198,0,0,1300,1301,3,196,98,0,1301, + 1302,5,199,0,0,1302,1363,1,0,0,0,1303,1304,5,119,0,0,1304,1305,5, + 198,0,0,1305,1306,3,196,98,0,1306,1307,5,199,0,0,1307,1363,1,0,0, + 0,1308,1309,5,120,0,0,1309,1310,5,198,0,0,1310,1311,3,196,98,0,1311, + 1312,5,199,0,0,1312,1363,1,0,0,0,1313,1314,5,121,0,0,1314,1315,5, + 198,0,0,1315,1316,3,196,98,0,1316,1317,5,199,0,0,1317,1363,1,0,0, + 0,1318,1319,5,122,0,0,1319,1320,5,198,0,0,1320,1321,3,196,98,0,1321, + 1322,5,199,0,0,1322,1363,1,0,0,0,1323,1324,5,123,0,0,1324,1325,5, + 198,0,0,1325,1326,3,196,98,0,1326,1327,5,199,0,0,1327,1363,1,0,0, + 0,1328,1329,5,124,0,0,1329,1330,5,198,0,0,1330,1331,3,196,98,0,1331, + 1332,5,199,0,0,1332,1363,1,0,0,0,1333,1334,5,125,0,0,1334,1335,5, + 198,0,0,1335,1336,3,196,98,0,1336,1337,5,199,0,0,1337,1363,1,0,0, + 0,1338,1339,5,126,0,0,1339,1340,5,198,0,0,1340,1341,3,196,98,0,1341, + 1342,5,199,0,0,1342,1363,1,0,0,0,1343,1344,5,127,0,0,1344,1345,5, + 198,0,0,1345,1346,3,196,98,0,1346,1347,5,199,0,0,1347,1363,1,0,0, + 0,1348,1349,5,181,0,0,1349,1350,5,198,0,0,1350,1351,3,192,96,0,1351, + 1352,5,199,0,0,1352,1363,1,0,0,0,1353,1354,5,113,0,0,1354,1355,5, + 198,0,0,1355,1356,3,198,99,0,1356,1357,5,205,0,0,1357,1358,3,198, + 99,0,1358,1359,5,205,0,0,1359,1360,5,196,0,0,1360,1361,5,199,0,0, + 1361,1363,1,0,0,0,1362,1240,1,0,0,0,1362,1245,1,0,0,0,1362,1248, + 1,0,0,0,1362,1253,1,0,0,0,1362,1258,1,0,0,0,1362,1263,1,0,0,0,1362, + 1268,1,0,0,0,1362,1273,1,0,0,0,1362,1278,1,0,0,0,1362,1283,1,0,0, + 0,1362,1288,1,0,0,0,1362,1293,1,0,0,0,1362,1298,1,0,0,0,1362,1303, + 1,0,0,0,1362,1308,1,0,0,0,1362,1313,1,0,0,0,1362,1318,1,0,0,0,1362, + 1323,1,0,0,0,1362,1328,1,0,0,0,1362,1333,1,0,0,0,1362,1338,1,0,0, + 0,1362,1343,1,0,0,0,1362,1348,1,0,0,0,1362,1353,1,0,0,0,1363,195, + 1,0,0,0,1364,1365,5,128,0,0,1365,1366,5,198,0,0,1366,1367,3,184, + 92,0,1367,1368,5,199,0,0,1368,1371,1,0,0,0,1369,1371,3,184,92,0, + 1370,1364,1,0,0,0,1370,1369,1,0,0,0,1371,197,1,0,0,0,1372,1382,3, + 184,92,0,1373,1382,3,254,127,0,1374,1375,5,114,0,0,1375,1376,5,198, + 0,0,1376,1377,3,200,100,0,1377,1378,5,205,0,0,1378,1379,3,200,100, + 0,1379,1380,5,199,0,0,1380,1382,1,0,0,0,1381,1372,1,0,0,0,1381,1373, + 1,0,0,0,1381,1374,1,0,0,0,1382,199,1,0,0,0,1383,1386,3,226,113,0, + 1384,1386,3,254,127,0,1385,1383,1,0,0,0,1385,1384,1,0,0,0,1386,201, + 1,0,0,0,1387,1388,5,77,0,0,1388,1390,3,184,92,0,1389,1391,3,204, + 102,0,1390,1389,1,0,0,0,1391,1392,1,0,0,0,1392,1390,1,0,0,0,1392, + 1393,1,0,0,0,1393,1395,1,0,0,0,1394,1396,3,206,103,0,1395,1394,1, + 0,0,0,1395,1396,1,0,0,0,1396,1397,1,0,0,0,1397,1398,5,78,0,0,1398, + 203,1,0,0,0,1399,1400,5,51,0,0,1400,1401,3,184,92,0,1401,1402,5, + 79,0,0,1402,1403,3,208,104,0,1403,205,1,0,0,0,1404,1405,5,10,0,0, + 1405,1406,3,208,104,0,1406,207,1,0,0,0,1407,1412,3,184,92,0,1408, + 1409,5,205,0,0,1409,1411,3,184,92,0,1410,1408,1,0,0,0,1411,1414, + 1,0,0,0,1412,1410,1,0,0,0,1412,1413,1,0,0,0,1413,209,1,0,0,0,1414, + 1412,1,0,0,0,1415,1416,5,63,0,0,1416,1417,5,64,0,0,1417,1418,3,260, + 130,0,1418,211,1,0,0,0,1419,1420,5,65,0,0,1420,1421,3,214,107,0, + 1421,213,1,0,0,0,1422,1427,3,216,108,0,1423,1424,5,69,0,0,1424,1426, + 3,216,108,0,1425,1423,1,0,0,0,1426,1429,1,0,0,0,1427,1425,1,0,0, + 0,1427,1428,1,0,0,0,1428,1441,1,0,0,0,1429,1427,1,0,0,0,1430,1435, + 3,216,108,0,1431,1432,5,70,0,0,1432,1434,3,216,108,0,1433,1431,1, + 0,0,0,1434,1437,1,0,0,0,1435,1433,1,0,0,0,1435,1436,1,0,0,0,1436, + 1441,1,0,0,0,1437,1435,1,0,0,0,1438,1439,5,71,0,0,1439,1441,3,216, + 108,0,1440,1422,1,0,0,0,1440,1430,1,0,0,0,1440,1438,1,0,0,0,1441, + 215,1,0,0,0,1442,1443,5,198,0,0,1443,1444,3,214,107,0,1444,1445, + 5,199,0,0,1445,1448,1,0,0,0,1446,1448,3,218,109,0,1447,1442,1,0, + 0,0,1447,1446,1,0,0,0,1448,217,1,0,0,0,1449,1450,3,184,92,0,1450, + 1451,3,220,110,0,1451,1452,3,222,111,0,1452,1458,1,0,0,0,1453,1454, + 3,194,97,0,1454,1455,3,220,110,0,1455,1456,3,222,111,0,1456,1458, + 1,0,0,0,1457,1449,1,0,0,0,1457,1453,1,0,0,0,1458,219,1,0,0,0,1459, + 1475,5,207,0,0,1460,1475,5,218,0,0,1461,1475,5,209,0,0,1462,1475, + 5,208,0,0,1463,1464,5,209,0,0,1464,1475,5,207,0,0,1465,1466,5,208, + 0,0,1466,1475,5,207,0,0,1467,1475,5,219,0,0,1468,1475,5,80,0,0,1469, + 1475,5,81,0,0,1470,1471,5,71,0,0,1471,1475,5,81,0,0,1472,1475,5, + 82,0,0,1473,1475,5,83,0,0,1474,1459,1,0,0,0,1474,1460,1,0,0,0,1474, + 1461,1,0,0,0,1474,1462,1,0,0,0,1474,1463,1,0,0,0,1474,1465,1,0,0, + 0,1474,1467,1,0,0,0,1474,1468,1,0,0,0,1474,1469,1,0,0,0,1474,1470, + 1,0,0,0,1474,1472,1,0,0,0,1474,1473,1,0,0,0,1475,221,1,0,0,0,1476, + 1497,5,26,0,0,1477,1497,5,195,0,0,1478,1497,3,226,113,0,1479,1497, + 5,196,0,0,1480,1497,5,173,0,0,1481,1497,5,174,0,0,1482,1497,3,256, + 128,0,1483,1488,5,175,0,0,1484,1486,5,206,0,0,1485,1487,5,192,0, + 0,1486,1485,1,0,0,0,1486,1487,1,0,0,0,1487,1489,1,0,0,0,1488,1484, + 1,0,0,0,1488,1489,1,0,0,0,1489,1497,1,0,0,0,1490,1491,5,198,0,0, + 1491,1492,3,178,89,0,1492,1493,5,199,0,0,1493,1497,1,0,0,0,1494, + 1497,3,224,112,0,1495,1497,3,254,127,0,1496,1476,1,0,0,0,1496,1477, + 1,0,0,0,1496,1478,1,0,0,0,1496,1479,1,0,0,0,1496,1480,1,0,0,0,1496, + 1481,1,0,0,0,1496,1482,1,0,0,0,1496,1483,1,0,0,0,1496,1490,1,0,0, + 0,1496,1494,1,0,0,0,1496,1495,1,0,0,0,1497,223,1,0,0,0,1498,1499, + 5,198,0,0,1499,1504,3,222,111,0,1500,1501,5,205,0,0,1501,1503,3, + 222,111,0,1502,1500,1,0,0,0,1503,1506,1,0,0,0,1504,1502,1,0,0,0, + 1504,1505,1,0,0,0,1505,1507,1,0,0,0,1506,1504,1,0,0,0,1507,1508, + 5,199,0,0,1508,225,1,0,0,0,1509,1511,7,7,0,0,1510,1509,1,0,0,0,1510, + 1511,1,0,0,0,1511,1512,1,0,0,0,1512,1513,7,14,0,0,1513,227,1,0,0, + 0,1514,1515,5,53,0,0,1515,1516,5,97,0,0,1516,1517,5,98,0,0,1517, + 1527,3,230,115,0,1518,1519,5,53,0,0,1519,1527,5,103,0,0,1520,1521, + 5,53,0,0,1521,1527,5,104,0,0,1522,1523,5,53,0,0,1523,1527,5,105, + 0,0,1524,1525,5,53,0,0,1525,1527,3,214,107,0,1526,1514,1,0,0,0,1526, + 1518,1,0,0,0,1526,1520,1,0,0,0,1526,1522,1,0,0,0,1526,1524,1,0,0, + 0,1527,229,1,0,0,0,1528,1533,3,232,116,0,1529,1530,5,221,0,0,1530, + 1532,3,232,116,0,1531,1529,1,0,0,0,1532,1535,1,0,0,0,1533,1531,1, + 0,0,0,1533,1534,1,0,0,0,1534,231,1,0,0,0,1535,1533,1,0,0,0,1536, + 1537,3,260,130,0,1537,1538,3,236,118,0,1538,1539,3,234,117,0,1539, + 233,1,0,0,0,1540,1553,3,260,130,0,1541,1542,5,198,0,0,1542,1547, + 3,260,130,0,1543,1544,5,205,0,0,1544,1546,3,260,130,0,1545,1543, + 1,0,0,0,1546,1549,1,0,0,0,1547,1545,1,0,0,0,1547,1548,1,0,0,0,1548, + 1550,1,0,0,0,1549,1547,1,0,0,0,1550,1551,5,198,0,0,1551,1553,1,0, + 0,0,1552,1540,1,0,0,0,1552,1541,1,0,0,0,1553,235,1,0,0,0,1554,1555, + 7,15,0,0,1555,237,1,0,0,0,1556,1557,5,89,0,0,1557,1558,5,67,0,0, + 1558,1561,3,180,90,0,1559,1560,5,93,0,0,1560,1562,3,214,107,0,1561, + 1559,1,0,0,0,1561,1562,1,0,0,0,1562,1592,1,0,0,0,1563,1564,5,89, + 0,0,1564,1565,5,67,0,0,1565,1566,5,94,0,0,1566,1567,5,198,0,0,1567, + 1572,3,184,92,0,1568,1569,5,205,0,0,1569,1571,3,184,92,0,1570,1568, + 1,0,0,0,1571,1574,1,0,0,0,1572,1570,1,0,0,0,1572,1573,1,0,0,0,1573, + 1575,1,0,0,0,1574,1572,1,0,0,0,1575,1576,5,199,0,0,1576,1592,1,0, + 0,0,1577,1578,5,89,0,0,1578,1579,5,67,0,0,1579,1580,5,107,0,0,1580, + 1581,5,198,0,0,1581,1586,3,184,92,0,1582,1583,5,205,0,0,1583,1585, + 3,184,92,0,1584,1582,1,0,0,0,1585,1588,1,0,0,0,1586,1584,1,0,0,0, + 1586,1587,1,0,0,0,1587,1589,1,0,0,0,1588,1586,1,0,0,0,1589,1590, + 5,199,0,0,1590,1592,1,0,0,0,1591,1556,1,0,0,0,1591,1563,1,0,0,0, + 1591,1577,1,0,0,0,1592,239,1,0,0,0,1593,1594,5,66,0,0,1594,1595, + 5,67,0,0,1595,1596,3,242,121,0,1596,241,1,0,0,0,1597,1602,3,244, + 122,0,1598,1599,5,205,0,0,1599,1601,3,244,122,0,1600,1598,1,0,0, + 0,1601,1604,1,0,0,0,1602,1600,1,0,0,0,1602,1603,1,0,0,0,1603,243, + 1,0,0,0,1604,1602,1,0,0,0,1605,1607,3,184,92,0,1606,1608,7,16,0, + 0,1607,1606,1,0,0,0,1607,1608,1,0,0,0,1608,1611,1,0,0,0,1609,1610, + 5,86,0,0,1610,1612,7,17,0,0,1611,1609,1,0,0,0,1611,1612,1,0,0,0, + 1612,1622,1,0,0,0,1613,1615,3,194,97,0,1614,1616,7,16,0,0,1615,1614, + 1,0,0,0,1615,1616,1,0,0,0,1616,1619,1,0,0,0,1617,1618,5,86,0,0,1618, + 1620,7,17,0,0,1619,1617,1,0,0,0,1619,1620,1,0,0,0,1620,1622,1,0, + 0,0,1621,1605,1,0,0,0,1621,1613,1,0,0,0,1622,245,1,0,0,0,1623,1624, + 5,68,0,0,1624,1628,5,192,0,0,1625,1626,5,68,0,0,1626,1628,3,254, + 127,0,1627,1623,1,0,0,0,1627,1625,1,0,0,0,1628,247,1,0,0,0,1629, + 1630,5,96,0,0,1630,1634,5,192,0,0,1631,1632,5,96,0,0,1632,1634,3, + 254,127,0,1633,1629,1,0,0,0,1633,1631,1,0,0,0,1634,249,1,0,0,0,1635, + 1636,5,90,0,0,1636,1637,5,91,0,0,1637,251,1,0,0,0,1638,1639,5,15, + 0,0,1639,1641,7,18,0,0,1640,1638,1,0,0,0,1641,1644,1,0,0,0,1642, + 1640,1,0,0,0,1642,1643,1,0,0,0,1643,253,1,0,0,0,1644,1642,1,0,0, + 0,1645,1646,5,215,0,0,1646,1647,3,146,73,0,1647,255,1,0,0,0,1648, + 1735,5,129,0,0,1649,1735,5,130,0,0,1650,1735,5,131,0,0,1651,1735, + 5,132,0,0,1652,1735,5,133,0,0,1653,1735,5,134,0,0,1654,1735,5,135, + 0,0,1655,1735,5,136,0,0,1656,1735,5,137,0,0,1657,1735,5,138,0,0, + 1658,1735,5,139,0,0,1659,1660,5,140,0,0,1660,1661,5,215,0,0,1661, + 1735,3,258,129,0,1662,1663,5,141,0,0,1663,1664,5,215,0,0,1664,1735, + 3,258,129,0,1665,1666,5,142,0,0,1666,1667,5,215,0,0,1667,1735,3, + 258,129,0,1668,1669,5,143,0,0,1669,1670,5,215,0,0,1670,1735,3,258, + 129,0,1671,1672,5,144,0,0,1672,1673,5,215,0,0,1673,1735,3,258,129, + 0,1674,1675,5,145,0,0,1675,1676,5,215,0,0,1676,1735,3,258,129,0, + 1677,1678,5,146,0,0,1678,1679,5,215,0,0,1679,1735,3,258,129,0,1680, + 1681,5,147,0,0,1681,1682,5,215,0,0,1682,1735,3,258,129,0,1683,1684, + 5,148,0,0,1684,1685,5,215,0,0,1685,1735,3,258,129,0,1686,1735,5, + 149,0,0,1687,1735,5,150,0,0,1688,1735,5,151,0,0,1689,1690,5,152, + 0,0,1690,1691,5,215,0,0,1691,1735,3,258,129,0,1692,1693,5,153,0, + 0,1693,1694,5,215,0,0,1694,1735,3,258,129,0,1695,1696,5,154,0,0, + 1696,1697,5,215,0,0,1697,1735,3,258,129,0,1698,1735,5,155,0,0,1699, + 1735,5,156,0,0,1700,1735,5,157,0,0,1701,1702,5,158,0,0,1702,1703, + 5,215,0,0,1703,1735,3,258,129,0,1704,1705,5,159,0,0,1705,1706,5, + 215,0,0,1706,1735,3,258,129,0,1707,1708,5,160,0,0,1708,1709,5,215, + 0,0,1709,1735,3,258,129,0,1710,1735,5,161,0,0,1711,1735,5,162,0, + 0,1712,1735,5,163,0,0,1713,1714,5,164,0,0,1714,1715,5,215,0,0,1715, + 1735,3,258,129,0,1716,1717,5,165,0,0,1717,1718,5,215,0,0,1718,1735, + 3,258,129,0,1719,1720,5,166,0,0,1720,1721,5,215,0,0,1721,1735,3, + 258,129,0,1722,1735,5,167,0,0,1723,1735,5,168,0,0,1724,1735,5,169, + 0,0,1725,1726,5,170,0,0,1726,1727,5,215,0,0,1727,1735,3,258,129, + 0,1728,1729,5,171,0,0,1729,1730,5,215,0,0,1730,1735,3,258,129,0, + 1731,1732,5,172,0,0,1732,1733,5,215,0,0,1733,1735,3,258,129,0,1734, + 1648,1,0,0,0,1734,1649,1,0,0,0,1734,1650,1,0,0,0,1734,1651,1,0,0, + 0,1734,1652,1,0,0,0,1734,1653,1,0,0,0,1734,1654,1,0,0,0,1734,1655, + 1,0,0,0,1734,1656,1,0,0,0,1734,1657,1,0,0,0,1734,1658,1,0,0,0,1734, + 1659,1,0,0,0,1734,1662,1,0,0,0,1734,1665,1,0,0,0,1734,1668,1,0,0, + 0,1734,1671,1,0,0,0,1734,1674,1,0,0,0,1734,1677,1,0,0,0,1734,1680, + 1,0,0,0,1734,1683,1,0,0,0,1734,1686,1,0,0,0,1734,1687,1,0,0,0,1734, + 1688,1,0,0,0,1734,1689,1,0,0,0,1734,1692,1,0,0,0,1734,1695,1,0,0, + 0,1734,1698,1,0,0,0,1734,1699,1,0,0,0,1734,1700,1,0,0,0,1734,1701, + 1,0,0,0,1734,1704,1,0,0,0,1734,1707,1,0,0,0,1734,1710,1,0,0,0,1734, + 1711,1,0,0,0,1734,1712,1,0,0,0,1734,1713,1,0,0,0,1734,1716,1,0,0, + 0,1734,1719,1,0,0,0,1734,1722,1,0,0,0,1734,1723,1,0,0,0,1734,1724, + 1,0,0,0,1734,1725,1,0,0,0,1734,1728,1,0,0,0,1734,1731,1,0,0,0,1735, + 257,1,0,0,0,1736,1738,7,7,0,0,1737,1736,1,0,0,0,1737,1738,1,0,0, + 0,1738,1739,1,0,0,0,1739,1740,5,192,0,0,1740,259,1,0,0,0,1741,1742, + 3,284,142,0,1742,261,1,0,0,0,1743,1744,5,190,0,0,1744,1745,3,266, + 133,0,1745,1746,5,203,0,0,1746,1754,1,0,0,0,1747,1748,5,202,0,0, + 1748,1749,5,176,0,0,1749,1750,3,254,127,0,1750,1751,3,266,133,0, + 1751,1752,5,203,0,0,1752,1754,1,0,0,0,1753,1743,1,0,0,0,1753,1747, + 1,0,0,0,1754,263,1,0,0,0,1755,1756,5,191,0,0,1756,1757,3,266,133, + 0,1757,1758,5,203,0,0,1758,265,1,0,0,0,1759,1760,5,81,0,0,1760,1762, + 3,268,134,0,1761,1759,1,0,0,0,1761,1762,1,0,0,0,1762,1765,1,0,0, + 0,1763,1764,5,188,0,0,1764,1766,3,270,135,0,1765,1763,1,0,0,0,1765, + 1766,1,0,0,0,1766,1771,1,0,0,0,1767,1768,5,53,0,0,1768,1769,5,187, + 0,0,1769,1770,5,207,0,0,1770,1772,5,196,0,0,1771,1767,1,0,0,0,1771, + 1772,1,0,0,0,1772,1777,1,0,0,0,1773,1774,5,53,0,0,1774,1775,5,97, + 0,0,1775,1776,5,98,0,0,1776,1778,3,230,115,0,1777,1773,1,0,0,0,1777, + 1778,1,0,0,0,1778,1788,1,0,0,0,1779,1780,5,53,0,0,1780,1786,5,185, + 0,0,1781,1782,5,198,0,0,1782,1783,5,186,0,0,1783,1784,5,207,0,0, + 1784,1785,5,192,0,0,1785,1787,5,199,0,0,1786,1781,1,0,0,0,1786,1787, + 1,0,0,0,1787,1789,1,0,0,0,1788,1779,1,0,0,0,1788,1789,1,0,0,0,1789, + 1797,1,0,0,0,1790,1791,5,53,0,0,1791,1792,5,184,0,0,1792,1793,5, + 81,0,0,1793,1794,5,198,0,0,1794,1795,3,280,140,0,1795,1796,5,199, + 0,0,1796,1798,1,0,0,0,1797,1790,1,0,0,0,1797,1798,1,0,0,0,1798,1803, + 1,0,0,0,1799,1800,5,53,0,0,1800,1801,5,184,0,0,1801,1802,5,207,0, + 0,1802,1804,5,196,0,0,1803,1799,1,0,0,0,1803,1804,1,0,0,0,1804,1809, + 1,0,0,0,1805,1806,5,53,0,0,1806,1807,5,183,0,0,1807,1808,5,207,0, + 0,1808,1810,5,196,0,0,1809,1805,1,0,0,0,1809,1810,1,0,0,0,1810,1815, + 1,0,0,0,1811,1812,5,53,0,0,1812,1813,5,182,0,0,1813,1814,5,207,0, + 0,1814,1816,5,196,0,0,1815,1811,1,0,0,0,1815,1816,1,0,0,0,1816,1818, + 1,0,0,0,1817,1819,3,246,123,0,1818,1817,1,0,0,0,1818,1819,1,0,0, + 0,1819,1822,1,0,0,0,1820,1821,5,46,0,0,1821,1823,3,276,138,0,1822, + 1820,1,0,0,0,1822,1823,1,0,0,0,1823,267,1,0,0,0,1824,1825,7,19,0, + 0,1825,1826,5,181,0,0,1826,269,1,0,0,0,1827,1832,3,272,136,0,1828, + 1829,5,205,0,0,1829,1831,3,270,135,0,1830,1828,1,0,0,0,1831,1834, + 1,0,0,0,1832,1830,1,0,0,0,1832,1833,1,0,0,0,1833,271,1,0,0,0,1834, + 1832,1,0,0,0,1835,1861,3,282,141,0,1836,1837,5,198,0,0,1837,1840, + 3,274,137,0,1838,1839,5,65,0,0,1839,1841,3,214,107,0,1840,1838,1, + 0,0,0,1840,1841,1,0,0,0,1841,1846,1,0,0,0,1842,1843,5,63,0,0,1843, + 1844,5,189,0,0,1844,1845,5,207,0,0,1845,1847,3,282,141,0,1846,1842, + 1,0,0,0,1846,1847,1,0,0,0,1847,1851,1,0,0,0,1848,1849,5,66,0,0,1849, + 1850,5,67,0,0,1850,1852,3,242,121,0,1851,1848,1,0,0,0,1851,1852, + 1,0,0,0,1852,1854,1,0,0,0,1853,1855,3,246,123,0,1854,1853,1,0,0, + 0,1854,1855,1,0,0,0,1855,1857,1,0,0,0,1856,1858,3,248,124,0,1857, + 1856,1,0,0,0,1857,1858,1,0,0,0,1858,1859,1,0,0,0,1859,1860,5,199, + 0,0,1860,1862,1,0,0,0,1861,1836,1,0,0,0,1861,1862,1,0,0,0,1862,273, + 1,0,0,0,1863,1868,3,282,141,0,1864,1865,5,205,0,0,1865,1867,3,274, + 137,0,1866,1864,1,0,0,0,1867,1870,1,0,0,0,1868,1866,1,0,0,0,1868, + 1869,1,0,0,0,1869,275,1,0,0,0,1870,1868,1,0,0,0,1871,1874,3,278, + 139,0,1872,1873,5,205,0,0,1873,1875,3,276,138,0,1874,1872,1,0,0, + 0,1874,1875,1,0,0,0,1875,277,1,0,0,0,1876,1877,7,20,0,0,1877,279, + 1,0,0,0,1878,1881,5,196,0,0,1879,1880,5,205,0,0,1880,1882,3,280, + 140,0,1881,1879,1,0,0,0,1881,1882,1,0,0,0,1882,281,1,0,0,0,1883, + 1888,3,284,142,0,1884,1885,5,206,0,0,1885,1887,3,282,141,0,1886, + 1884,1,0,0,0,1887,1890,1,0,0,0,1888,1886,1,0,0,0,1888,1889,1,0,0, + 0,1889,283,1,0,0,0,1890,1888,1,0,0,0,1891,1892,7,21,0,0,1892,285, + 1,0,0,0,1893,1894,7,22,0,0,1894,287,1,0,0,0,189,298,311,319,326, + 333,337,343,347,355,364,371,380,387,396,403,409,413,434,443,447, + 453,469,477,482,493,499,507,511,513,522,531,536,540,544,548,550, + 558,567,573,584,594,597,601,606,616,624,627,630,638,649,675,682, + 691,705,711,714,725,733,739,752,755,758,762,781,788,795,802,809, + 813,819,828,839,844,849,854,861,874,878,882,884,888,906,927,943, + 949,986,998,1000,1016,1021,1028,1034,1037,1042,1052,1059,1067,1081, + 1083,1091,1106,1113,1126,1129,1132,1135,1138,1141,1144,1147,1152, + 1159,1162,1165,1170,1177,1182,1186,1192,1195,1202,1207,1212,1216, + 1224,1229,1233,1236,1362,1370,1381,1385,1392,1395,1412,1427,1435, + 1440,1447,1457,1474,1486,1488,1496,1504,1510,1526,1533,1547,1552, + 1561,1572,1586,1591,1602,1607,1611,1615,1619,1621,1627,1633,1642, + 1734,1737,1753,1761,1765,1771,1777,1786,1788,1797,1803,1809,1815, + 1818,1822,1832,1840,1846,1851,1854,1857,1861,1868,1874,1881,1888 + ]; + + private static __ATN: antlr.ATN; + public static get _ATN(): antlr.ATN { + if (!ApexParser.__ATN) { + ApexParser.__ATN = new antlr.ATNDeserializer().deserialize(ApexParser._serializedATN); + } + + return ApexParser.__ATN; + } + + + private static readonly vocabulary = new antlr.Vocabulary(ApexParser.literalNames, ApexParser.symbolicNames, []); + + public override get vocabulary(): antlr.Vocabulary { + return ApexParser.vocabulary; + } + + private static readonly decisionsToDFA = ApexParser._ATN.decisionToState.map( (ds: antlr.DecisionState, index: number) => new antlr.DFA(ds, index) ); +} + +export class TriggerUnitContext extends antlr.ParserRuleContext { + public _object?: IdContext; + public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { + super(parent, invokingState); + } + public TRIGGER(): antlr.TerminalNode { + return this.getToken(ApexParser.TRIGGER, 0)!; + } + public id(): IdContext[]; + public id(i: number): IdContext | null; + public id(i?: number): IdContext[] | IdContext | null { + if (i === undefined) { + return this.getRuleContexts(IdContext); + } + + return this.getRuleContext(i, IdContext); + } + public ON(): antlr.TerminalNode { + return this.getToken(ApexParser.ON, 0)!; + } + public LPAREN(): antlr.TerminalNode { + return this.getToken(ApexParser.LPAREN, 0)!; + } + public triggerCase(): TriggerCaseContext[]; + public triggerCase(i: number): TriggerCaseContext | null; + public triggerCase(i?: number): TriggerCaseContext[] | TriggerCaseContext | null { + if (i === undefined) { + return this.getRuleContexts(TriggerCaseContext); + } + + return this.getRuleContext(i, TriggerCaseContext); + } + public RPAREN(): antlr.TerminalNode { + return this.getToken(ApexParser.RPAREN, 0)!; + } + public block(): BlockContext { + return this.getRuleContext(0, BlockContext)!; + } + public EOF(): antlr.TerminalNode { + return this.getToken(ApexParser.EOF, 0)!; + } + public COMMA(): antlr.TerminalNode[]; + public COMMA(i: number): antlr.TerminalNode | null; + public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { + if (i === undefined) { + return this.getTokens(ApexParser.COMMA); + } else { + return this.getToken(ApexParser.COMMA, i); + } + } + public override get ruleIndex(): number { + return ApexParser.RULE_triggerUnit; + } + public override enterRule(listener: ApexParserListener): void { + if(listener.enterTriggerUnit) { + listener.enterTriggerUnit(this); + } + } + public override exitRule(listener: ApexParserListener): void { + if(listener.exitTriggerUnit) { + listener.exitTriggerUnit(this); + } + } + public override accept(visitor: ApexParserVisitor): Result | null { + if (visitor.visitTriggerUnit) { + return visitor.visitTriggerUnit(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class TriggerCaseContext extends antlr.ParserRuleContext { + public _when?: Token | null; + public _operation?: Token | null; + public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { + super(parent, invokingState); + } + public BEFORE(): antlr.TerminalNode | null { + return this.getToken(ApexParser.BEFORE, 0); + } + public AFTER(): antlr.TerminalNode | null { + return this.getToken(ApexParser.AFTER, 0); + } + public INSERT(): antlr.TerminalNode | null { + return this.getToken(ApexParser.INSERT, 0); + } + public UPDATE(): antlr.TerminalNode | null { + return this.getToken(ApexParser.UPDATE, 0); + } + public DELETE(): antlr.TerminalNode | null { + return this.getToken(ApexParser.DELETE, 0); + } + public UNDELETE(): antlr.TerminalNode | null { + return this.getToken(ApexParser.UNDELETE, 0); + } + public override get ruleIndex(): number { + return ApexParser.RULE_triggerCase; + } + public override enterRule(listener: ApexParserListener): void { + if(listener.enterTriggerCase) { + listener.enterTriggerCase(this); + } + } + public override exitRule(listener: ApexParserListener): void { + if(listener.exitTriggerCase) { + listener.exitTriggerCase(this); + } + } + public override accept(visitor: ApexParserVisitor): Result | null { + if (visitor.visitTriggerCase) { + return visitor.visitTriggerCase(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class CompilationUnitContext extends antlr.ParserRuleContext { + public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { + super(parent, invokingState); + } + public EOF(): antlr.TerminalNode { + return this.getToken(ApexParser.EOF, 0)!; + } + public typeDeclaration(): TypeDeclarationContext[]; + public typeDeclaration(i: number): TypeDeclarationContext | null; + public typeDeclaration(i?: number): TypeDeclarationContext[] | TypeDeclarationContext | null { + if (i === undefined) { + return this.getRuleContexts(TypeDeclarationContext); + } + + return this.getRuleContext(i, TypeDeclarationContext); + } + public override get ruleIndex(): number { + return ApexParser.RULE_compilationUnit; + } + public override enterRule(listener: ApexParserListener): void { + if(listener.enterCompilationUnit) { + listener.enterCompilationUnit(this); + } + } + public override exitRule(listener: ApexParserListener): void { + if(listener.exitCompilationUnit) { + listener.exitCompilationUnit(this); + } + } + public override accept(visitor: ApexParserVisitor): Result | null { + if (visitor.visitCompilationUnit) { + return visitor.visitCompilationUnit(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class TypeDeclarationContext extends antlr.ParserRuleContext { + public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { + super(parent, invokingState); + } + public classDeclaration(): ClassDeclarationContext | null { + return this.getRuleContext(0, ClassDeclarationContext); + } + public modifier(): ModifierContext[]; + public modifier(i: number): ModifierContext | null; + public modifier(i?: number): ModifierContext[] | ModifierContext | null { + if (i === undefined) { + return this.getRuleContexts(ModifierContext); + } + + return this.getRuleContext(i, ModifierContext); + } + public enumDeclaration(): EnumDeclarationContext | null { + return this.getRuleContext(0, EnumDeclarationContext); + } + public interfaceDeclaration(): InterfaceDeclarationContext | null { + return this.getRuleContext(0, InterfaceDeclarationContext); + } + public override get ruleIndex(): number { + return ApexParser.RULE_typeDeclaration; + } + public override enterRule(listener: ApexParserListener): void { + if(listener.enterTypeDeclaration) { + listener.enterTypeDeclaration(this); + } + } + public override exitRule(listener: ApexParserListener): void { + if(listener.exitTypeDeclaration) { + listener.exitTypeDeclaration(this); + } + } + public override accept(visitor: ApexParserVisitor): Result | null { + if (visitor.visitTypeDeclaration) { + return visitor.visitTypeDeclaration(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class ClassDeclarationContext extends antlr.ParserRuleContext { + public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { + super(parent, invokingState); + } + public CLASS(): antlr.TerminalNode { + return this.getToken(ApexParser.CLASS, 0)!; + } + public id(): IdContext { + return this.getRuleContext(0, IdContext)!; + } + public classBody(): ClassBodyContext { + return this.getRuleContext(0, ClassBodyContext)!; + } + public EXTENDS(): antlr.TerminalNode | null { + return this.getToken(ApexParser.EXTENDS, 0); + } + public typeRef(): TypeRefContext | null { + return this.getRuleContext(0, TypeRefContext); + } + public IMPLEMENTS(): antlr.TerminalNode | null { + return this.getToken(ApexParser.IMPLEMENTS, 0); + } + public typeList(): TypeListContext | null { + return this.getRuleContext(0, TypeListContext); + } + public override get ruleIndex(): number { + return ApexParser.RULE_classDeclaration; + } + public override enterRule(listener: ApexParserListener): void { + if(listener.enterClassDeclaration) { + listener.enterClassDeclaration(this); + } + } + public override exitRule(listener: ApexParserListener): void { + if(listener.exitClassDeclaration) { + listener.exitClassDeclaration(this); + } + } + public override accept(visitor: ApexParserVisitor): Result | null { + if (visitor.visitClassDeclaration) { + return visitor.visitClassDeclaration(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class EnumDeclarationContext extends antlr.ParserRuleContext { + public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { + super(parent, invokingState); + } + public ENUM(): antlr.TerminalNode { + return this.getToken(ApexParser.ENUM, 0)!; + } + public id(): IdContext { + return this.getRuleContext(0, IdContext)!; + } + public LBRACE(): antlr.TerminalNode { + return this.getToken(ApexParser.LBRACE, 0)!; + } + public RBRACE(): antlr.TerminalNode { + return this.getToken(ApexParser.RBRACE, 0)!; + } + public enumConstants(): EnumConstantsContext | null { + return this.getRuleContext(0, EnumConstantsContext); + } + public override get ruleIndex(): number { + return ApexParser.RULE_enumDeclaration; + } + public override enterRule(listener: ApexParserListener): void { + if(listener.enterEnumDeclaration) { + listener.enterEnumDeclaration(this); + } + } + public override exitRule(listener: ApexParserListener): void { + if(listener.exitEnumDeclaration) { + listener.exitEnumDeclaration(this); + } + } + public override accept(visitor: ApexParserVisitor): Result | null { + if (visitor.visitEnumDeclaration) { + return visitor.visitEnumDeclaration(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class EnumConstantsContext extends antlr.ParserRuleContext { + public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { + super(parent, invokingState); + } + public id(): IdContext[]; + public id(i: number): IdContext | null; + public id(i?: number): IdContext[] | IdContext | null { + if (i === undefined) { + return this.getRuleContexts(IdContext); + } + + return this.getRuleContext(i, IdContext); + } + public COMMA(): antlr.TerminalNode[]; + public COMMA(i: number): antlr.TerminalNode | null; + public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { + if (i === undefined) { + return this.getTokens(ApexParser.COMMA); + } else { + return this.getToken(ApexParser.COMMA, i); + } + } + public override get ruleIndex(): number { + return ApexParser.RULE_enumConstants; + } + public override enterRule(listener: ApexParserListener): void { + if(listener.enterEnumConstants) { + listener.enterEnumConstants(this); + } + } + public override exitRule(listener: ApexParserListener): void { + if(listener.exitEnumConstants) { + listener.exitEnumConstants(this); + } + } + public override accept(visitor: ApexParserVisitor): Result | null { + if (visitor.visitEnumConstants) { + return visitor.visitEnumConstants(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class InterfaceDeclarationContext extends antlr.ParserRuleContext { + public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { + super(parent, invokingState); + } + public INTERFACE(): antlr.TerminalNode { + return this.getToken(ApexParser.INTERFACE, 0)!; + } + public id(): IdContext { + return this.getRuleContext(0, IdContext)!; + } + public interfaceBody(): InterfaceBodyContext { + return this.getRuleContext(0, InterfaceBodyContext)!; + } + public EXTENDS(): antlr.TerminalNode | null { + return this.getToken(ApexParser.EXTENDS, 0); + } + public typeList(): TypeListContext | null { + return this.getRuleContext(0, TypeListContext); + } + public override get ruleIndex(): number { + return ApexParser.RULE_interfaceDeclaration; + } + public override enterRule(listener: ApexParserListener): void { + if(listener.enterInterfaceDeclaration) { + listener.enterInterfaceDeclaration(this); + } + } + public override exitRule(listener: ApexParserListener): void { + if(listener.exitInterfaceDeclaration) { + listener.exitInterfaceDeclaration(this); + } + } + public override accept(visitor: ApexParserVisitor): Result | null { + if (visitor.visitInterfaceDeclaration) { + return visitor.visitInterfaceDeclaration(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class TypeListContext extends antlr.ParserRuleContext { + public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { + super(parent, invokingState); + } + public typeRef(): TypeRefContext[]; + public typeRef(i: number): TypeRefContext | null; + public typeRef(i?: number): TypeRefContext[] | TypeRefContext | null { + if (i === undefined) { + return this.getRuleContexts(TypeRefContext); + } + + return this.getRuleContext(i, TypeRefContext); + } + public COMMA(): antlr.TerminalNode[]; + public COMMA(i: number): antlr.TerminalNode | null; + public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { + if (i === undefined) { + return this.getTokens(ApexParser.COMMA); + } else { + return this.getToken(ApexParser.COMMA, i); + } + } + public override get ruleIndex(): number { + return ApexParser.RULE_typeList; + } + public override enterRule(listener: ApexParserListener): void { + if(listener.enterTypeList) { + listener.enterTypeList(this); + } + } + public override exitRule(listener: ApexParserListener): void { + if(listener.exitTypeList) { + listener.exitTypeList(this); + } + } + public override accept(visitor: ApexParserVisitor): Result | null { + if (visitor.visitTypeList) { + return visitor.visitTypeList(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class ClassBodyContext extends antlr.ParserRuleContext { + public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { + super(parent, invokingState); + } + public LBRACE(): antlr.TerminalNode { + return this.getToken(ApexParser.LBRACE, 0)!; + } + public RBRACE(): antlr.TerminalNode { + return this.getToken(ApexParser.RBRACE, 0)!; + } + public classBodyDeclaration(): ClassBodyDeclarationContext[]; + public classBodyDeclaration(i: number): ClassBodyDeclarationContext | null; + public classBodyDeclaration(i?: number): ClassBodyDeclarationContext[] | ClassBodyDeclarationContext | null { + if (i === undefined) { + return this.getRuleContexts(ClassBodyDeclarationContext); + } + + return this.getRuleContext(i, ClassBodyDeclarationContext); + } + public override get ruleIndex(): number { + return ApexParser.RULE_classBody; + } + public override enterRule(listener: ApexParserListener): void { + if(listener.enterClassBody) { + listener.enterClassBody(this); + } + } + public override exitRule(listener: ApexParserListener): void { + if(listener.exitClassBody) { + listener.exitClassBody(this); + } + } + public override accept(visitor: ApexParserVisitor): Result | null { + if (visitor.visitClassBody) { + return visitor.visitClassBody(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class InterfaceBodyContext extends antlr.ParserRuleContext { + public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { + super(parent, invokingState); + } + public LBRACE(): antlr.TerminalNode { + return this.getToken(ApexParser.LBRACE, 0)!; + } + public RBRACE(): antlr.TerminalNode { + return this.getToken(ApexParser.RBRACE, 0)!; + } + public interfaceMethodDeclaration(): InterfaceMethodDeclarationContext[]; + public interfaceMethodDeclaration(i: number): InterfaceMethodDeclarationContext | null; + public interfaceMethodDeclaration(i?: number): InterfaceMethodDeclarationContext[] | InterfaceMethodDeclarationContext | null { + if (i === undefined) { + return this.getRuleContexts(InterfaceMethodDeclarationContext); + } + + return this.getRuleContext(i, InterfaceMethodDeclarationContext); + } + public override get ruleIndex(): number { + return ApexParser.RULE_interfaceBody; + } + public override enterRule(listener: ApexParserListener): void { + if(listener.enterInterfaceBody) { + listener.enterInterfaceBody(this); + } + } + public override exitRule(listener: ApexParserListener): void { + if(listener.exitInterfaceBody) { + listener.exitInterfaceBody(this); + } + } + public override accept(visitor: ApexParserVisitor): Result | null { + if (visitor.visitInterfaceBody) { + return visitor.visitInterfaceBody(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class ClassBodyDeclarationContext extends antlr.ParserRuleContext { + public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { + super(parent, invokingState); + } + public SEMI(): antlr.TerminalNode | null { + return this.getToken(ApexParser.SEMI, 0); + } + public block(): BlockContext | null { + return this.getRuleContext(0, BlockContext); + } + public STATIC(): antlr.TerminalNode | null { + return this.getToken(ApexParser.STATIC, 0); + } + public memberDeclaration(): MemberDeclarationContext | null { + return this.getRuleContext(0, MemberDeclarationContext); + } + public modifier(): ModifierContext[]; + public modifier(i: number): ModifierContext | null; + public modifier(i?: number): ModifierContext[] | ModifierContext | null { + if (i === undefined) { + return this.getRuleContexts(ModifierContext); + } + + return this.getRuleContext(i, ModifierContext); + } + public override get ruleIndex(): number { + return ApexParser.RULE_classBodyDeclaration; + } + public override enterRule(listener: ApexParserListener): void { + if(listener.enterClassBodyDeclaration) { + listener.enterClassBodyDeclaration(this); + } + } + public override exitRule(listener: ApexParserListener): void { + if(listener.exitClassBodyDeclaration) { + listener.exitClassBodyDeclaration(this); + } + } + public override accept(visitor: ApexParserVisitor): Result | null { + if (visitor.visitClassBodyDeclaration) { + return visitor.visitClassBodyDeclaration(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class ModifierContext extends antlr.ParserRuleContext { + public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { + super(parent, invokingState); + } + public annotation(): AnnotationContext | null { + return this.getRuleContext(0, AnnotationContext); + } + public GLOBAL(): antlr.TerminalNode | null { + return this.getToken(ApexParser.GLOBAL, 0); + } + public PUBLIC(): antlr.TerminalNode | null { + return this.getToken(ApexParser.PUBLIC, 0); + } + public PROTECTED(): antlr.TerminalNode | null { + return this.getToken(ApexParser.PROTECTED, 0); + } + public PRIVATE(): antlr.TerminalNode | null { + return this.getToken(ApexParser.PRIVATE, 0); + } + public TRANSIENT(): antlr.TerminalNode | null { + return this.getToken(ApexParser.TRANSIENT, 0); + } + public STATIC(): antlr.TerminalNode | null { + return this.getToken(ApexParser.STATIC, 0); + } + public ABSTRACT(): antlr.TerminalNode | null { + return this.getToken(ApexParser.ABSTRACT, 0); + } + public FINAL(): antlr.TerminalNode | null { + return this.getToken(ApexParser.FINAL, 0); + } + public WEBSERVICE(): antlr.TerminalNode | null { + return this.getToken(ApexParser.WEBSERVICE, 0); + } + public OVERRIDE(): antlr.TerminalNode | null { + return this.getToken(ApexParser.OVERRIDE, 0); + } + public VIRTUAL(): antlr.TerminalNode | null { + return this.getToken(ApexParser.VIRTUAL, 0); + } + public TESTMETHOD(): antlr.TerminalNode | null { + return this.getToken(ApexParser.TESTMETHOD, 0); + } + public WITH(): antlr.TerminalNode | null { + return this.getToken(ApexParser.WITH, 0); + } + public SHARING(): antlr.TerminalNode | null { + return this.getToken(ApexParser.SHARING, 0); + } + public WITHOUT(): antlr.TerminalNode | null { + return this.getToken(ApexParser.WITHOUT, 0); + } + public INHERITED(): antlr.TerminalNode | null { + return this.getToken(ApexParser.INHERITED, 0); + } + public override get ruleIndex(): number { + return ApexParser.RULE_modifier; + } + public override enterRule(listener: ApexParserListener): void { + if(listener.enterModifier) { + listener.enterModifier(this); + } + } + public override exitRule(listener: ApexParserListener): void { + if(listener.exitModifier) { + listener.exitModifier(this); + } + } + public override accept(visitor: ApexParserVisitor): Result | null { + if (visitor.visitModifier) { + return visitor.visitModifier(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class MemberDeclarationContext extends antlr.ParserRuleContext { + public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { + super(parent, invokingState); + } + public methodDeclaration(): MethodDeclarationContext | null { + return this.getRuleContext(0, MethodDeclarationContext); + } + public fieldDeclaration(): FieldDeclarationContext | null { + return this.getRuleContext(0, FieldDeclarationContext); + } + public constructorDeclaration(): ConstructorDeclarationContext | null { + return this.getRuleContext(0, ConstructorDeclarationContext); + } + public interfaceDeclaration(): InterfaceDeclarationContext | null { + return this.getRuleContext(0, InterfaceDeclarationContext); + } + public classDeclaration(): ClassDeclarationContext | null { + return this.getRuleContext(0, ClassDeclarationContext); + } + public enumDeclaration(): EnumDeclarationContext | null { + return this.getRuleContext(0, EnumDeclarationContext); + } + public propertyDeclaration(): PropertyDeclarationContext | null { + return this.getRuleContext(0, PropertyDeclarationContext); + } + public override get ruleIndex(): number { + return ApexParser.RULE_memberDeclaration; + } + public override enterRule(listener: ApexParserListener): void { + if(listener.enterMemberDeclaration) { + listener.enterMemberDeclaration(this); + } + } + public override exitRule(listener: ApexParserListener): void { + if(listener.exitMemberDeclaration) { + listener.exitMemberDeclaration(this); + } + } + public override accept(visitor: ApexParserVisitor): Result | null { + if (visitor.visitMemberDeclaration) { + return visitor.visitMemberDeclaration(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class MethodDeclarationContext extends antlr.ParserRuleContext { + public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { + super(parent, invokingState); + } + public id(): IdContext { + return this.getRuleContext(0, IdContext)!; + } + public formalParameters(): FormalParametersContext { + return this.getRuleContext(0, FormalParametersContext)!; + } + public typeRef(): TypeRefContext | null { + return this.getRuleContext(0, TypeRefContext); + } + public VOID(): antlr.TerminalNode | null { + return this.getToken(ApexParser.VOID, 0); + } + public block(): BlockContext | null { + return this.getRuleContext(0, BlockContext); + } + public SEMI(): antlr.TerminalNode | null { + return this.getToken(ApexParser.SEMI, 0); + } + public override get ruleIndex(): number { + return ApexParser.RULE_methodDeclaration; + } + public override enterRule(listener: ApexParserListener): void { + if(listener.enterMethodDeclaration) { + listener.enterMethodDeclaration(this); + } + } + public override exitRule(listener: ApexParserListener): void { + if(listener.exitMethodDeclaration) { + listener.exitMethodDeclaration(this); + } + } + public override accept(visitor: ApexParserVisitor): Result | null { + if (visitor.visitMethodDeclaration) { + return visitor.visitMethodDeclaration(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class ConstructorDeclarationContext extends antlr.ParserRuleContext { + public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { + super(parent, invokingState); + } + public qualifiedName(): QualifiedNameContext { + return this.getRuleContext(0, QualifiedNameContext)!; + } + public formalParameters(): FormalParametersContext { + return this.getRuleContext(0, FormalParametersContext)!; + } + public block(): BlockContext { + return this.getRuleContext(0, BlockContext)!; + } + public override get ruleIndex(): number { + return ApexParser.RULE_constructorDeclaration; + } + public override enterRule(listener: ApexParserListener): void { + if(listener.enterConstructorDeclaration) { + listener.enterConstructorDeclaration(this); + } + } + public override exitRule(listener: ApexParserListener): void { + if(listener.exitConstructorDeclaration) { + listener.exitConstructorDeclaration(this); + } + } + public override accept(visitor: ApexParserVisitor): Result | null { + if (visitor.visitConstructorDeclaration) { + return visitor.visitConstructorDeclaration(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class FieldDeclarationContext extends antlr.ParserRuleContext { + public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { + super(parent, invokingState); + } + public typeRef(): TypeRefContext { + return this.getRuleContext(0, TypeRefContext)!; + } + public variableDeclarators(): VariableDeclaratorsContext { + return this.getRuleContext(0, VariableDeclaratorsContext)!; + } + public SEMI(): antlr.TerminalNode { + return this.getToken(ApexParser.SEMI, 0)!; + } + public override get ruleIndex(): number { + return ApexParser.RULE_fieldDeclaration; + } + public override enterRule(listener: ApexParserListener): void { + if(listener.enterFieldDeclaration) { + listener.enterFieldDeclaration(this); + } + } + public override exitRule(listener: ApexParserListener): void { + if(listener.exitFieldDeclaration) { + listener.exitFieldDeclaration(this); + } + } + public override accept(visitor: ApexParserVisitor): Result | null { + if (visitor.visitFieldDeclaration) { + return visitor.visitFieldDeclaration(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class PropertyDeclarationContext extends antlr.ParserRuleContext { + public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { + super(parent, invokingState); + } + public typeRef(): TypeRefContext { + return this.getRuleContext(0, TypeRefContext)!; + } + public id(): IdContext { + return this.getRuleContext(0, IdContext)!; + } + public LBRACE(): antlr.TerminalNode { + return this.getToken(ApexParser.LBRACE, 0)!; + } + public RBRACE(): antlr.TerminalNode { + return this.getToken(ApexParser.RBRACE, 0)!; + } + public propertyBlock(): PropertyBlockContext[]; + public propertyBlock(i: number): PropertyBlockContext | null; + public propertyBlock(i?: number): PropertyBlockContext[] | PropertyBlockContext | null { + if (i === undefined) { + return this.getRuleContexts(PropertyBlockContext); + } + + return this.getRuleContext(i, PropertyBlockContext); + } + public override get ruleIndex(): number { + return ApexParser.RULE_propertyDeclaration; + } + public override enterRule(listener: ApexParserListener): void { + if(listener.enterPropertyDeclaration) { + listener.enterPropertyDeclaration(this); + } + } + public override exitRule(listener: ApexParserListener): void { + if(listener.exitPropertyDeclaration) { + listener.exitPropertyDeclaration(this); + } + } + public override accept(visitor: ApexParserVisitor): Result | null { + if (visitor.visitPropertyDeclaration) { + return visitor.visitPropertyDeclaration(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class InterfaceMethodDeclarationContext extends antlr.ParserRuleContext { + public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { + super(parent, invokingState); + } + public id(): IdContext { + return this.getRuleContext(0, IdContext)!; + } + public formalParameters(): FormalParametersContext { + return this.getRuleContext(0, FormalParametersContext)!; + } + public SEMI(): antlr.TerminalNode { + return this.getToken(ApexParser.SEMI, 0)!; + } + public typeRef(): TypeRefContext | null { + return this.getRuleContext(0, TypeRefContext); + } + public VOID(): antlr.TerminalNode | null { + return this.getToken(ApexParser.VOID, 0); + } + public modifier(): ModifierContext[]; + public modifier(i: number): ModifierContext | null; + public modifier(i?: number): ModifierContext[] | ModifierContext | null { + if (i === undefined) { + return this.getRuleContexts(ModifierContext); + } + + return this.getRuleContext(i, ModifierContext); + } + public override get ruleIndex(): number { + return ApexParser.RULE_interfaceMethodDeclaration; + } + public override enterRule(listener: ApexParserListener): void { + if(listener.enterInterfaceMethodDeclaration) { + listener.enterInterfaceMethodDeclaration(this); + } + } + public override exitRule(listener: ApexParserListener): void { + if(listener.exitInterfaceMethodDeclaration) { + listener.exitInterfaceMethodDeclaration(this); + } + } + public override accept(visitor: ApexParserVisitor): Result | null { + if (visitor.visitInterfaceMethodDeclaration) { + return visitor.visitInterfaceMethodDeclaration(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class VariableDeclaratorsContext extends antlr.ParserRuleContext { + public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { + super(parent, invokingState); + } + public variableDeclarator(): VariableDeclaratorContext[]; + public variableDeclarator(i: number): VariableDeclaratorContext | null; + public variableDeclarator(i?: number): VariableDeclaratorContext[] | VariableDeclaratorContext | null { + if (i === undefined) { + return this.getRuleContexts(VariableDeclaratorContext); + } + + return this.getRuleContext(i, VariableDeclaratorContext); + } + public COMMA(): antlr.TerminalNode[]; + public COMMA(i: number): antlr.TerminalNode | null; + public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { + if (i === undefined) { + return this.getTokens(ApexParser.COMMA); + } else { + return this.getToken(ApexParser.COMMA, i); + } + } + public override get ruleIndex(): number { + return ApexParser.RULE_variableDeclarators; + } + public override enterRule(listener: ApexParserListener): void { + if(listener.enterVariableDeclarators) { + listener.enterVariableDeclarators(this); + } + } + public override exitRule(listener: ApexParserListener): void { + if(listener.exitVariableDeclarators) { + listener.exitVariableDeclarators(this); + } + } + public override accept(visitor: ApexParserVisitor): Result | null { + if (visitor.visitVariableDeclarators) { + return visitor.visitVariableDeclarators(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class VariableDeclaratorContext extends antlr.ParserRuleContext { + public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { + super(parent, invokingState); + } + public id(): IdContext { + return this.getRuleContext(0, IdContext)!; + } + public ASSIGN(): antlr.TerminalNode | null { + return this.getToken(ApexParser.ASSIGN, 0); + } + public expression(): ExpressionContext | null { + return this.getRuleContext(0, ExpressionContext); + } + public override get ruleIndex(): number { + return ApexParser.RULE_variableDeclarator; + } + public override enterRule(listener: ApexParserListener): void { + if(listener.enterVariableDeclarator) { + listener.enterVariableDeclarator(this); + } + } + public override exitRule(listener: ApexParserListener): void { + if(listener.exitVariableDeclarator) { + listener.exitVariableDeclarator(this); + } + } + public override accept(visitor: ApexParserVisitor): Result | null { + if (visitor.visitVariableDeclarator) { + return visitor.visitVariableDeclarator(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class ArrayInitializerContext extends antlr.ParserRuleContext { + public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { + super(parent, invokingState); + } + public LBRACE(): antlr.TerminalNode { + return this.getToken(ApexParser.LBRACE, 0)!; + } + public RBRACE(): antlr.TerminalNode { + return this.getToken(ApexParser.RBRACE, 0)!; + } + public expression(): ExpressionContext[]; + public expression(i: number): ExpressionContext | null; + public expression(i?: number): ExpressionContext[] | ExpressionContext | null { + if (i === undefined) { + return this.getRuleContexts(ExpressionContext); + } + + return this.getRuleContext(i, ExpressionContext); + } + public COMMA(): antlr.TerminalNode[]; + public COMMA(i: number): antlr.TerminalNode | null; + public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { + if (i === undefined) { + return this.getTokens(ApexParser.COMMA); + } else { + return this.getToken(ApexParser.COMMA, i); + } + } + public override get ruleIndex(): number { + return ApexParser.RULE_arrayInitializer; + } + public override enterRule(listener: ApexParserListener): void { + if(listener.enterArrayInitializer) { + listener.enterArrayInitializer(this); + } + } + public override exitRule(listener: ApexParserListener): void { + if(listener.exitArrayInitializer) { + listener.exitArrayInitializer(this); + } + } + public override accept(visitor: ApexParserVisitor): Result | null { + if (visitor.visitArrayInitializer) { + return visitor.visitArrayInitializer(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class TypeRefContext extends antlr.ParserRuleContext { + public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { + super(parent, invokingState); + } + public typeName(): TypeNameContext[]; + public typeName(i: number): TypeNameContext | null; + public typeName(i?: number): TypeNameContext[] | TypeNameContext | null { + if (i === undefined) { + return this.getRuleContexts(TypeNameContext); + } + + return this.getRuleContext(i, TypeNameContext); + } + public arraySubscripts(): ArraySubscriptsContext { + return this.getRuleContext(0, ArraySubscriptsContext)!; + } + public DOT(): antlr.TerminalNode[]; + public DOT(i: number): antlr.TerminalNode | null; + public DOT(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { + if (i === undefined) { + return this.getTokens(ApexParser.DOT); + } else { + return this.getToken(ApexParser.DOT, i); + } + } + public override get ruleIndex(): number { + return ApexParser.RULE_typeRef; + } + public override enterRule(listener: ApexParserListener): void { + if(listener.enterTypeRef) { + listener.enterTypeRef(this); + } + } + public override exitRule(listener: ApexParserListener): void { + if(listener.exitTypeRef) { + listener.exitTypeRef(this); + } + } + public override accept(visitor: ApexParserVisitor): Result | null { + if (visitor.visitTypeRef) { + return visitor.visitTypeRef(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class ArraySubscriptsContext extends antlr.ParserRuleContext { + public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { + super(parent, invokingState); + } + public LBRACK(): antlr.TerminalNode[]; + public LBRACK(i: number): antlr.TerminalNode | null; + public LBRACK(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { + if (i === undefined) { + return this.getTokens(ApexParser.LBRACK); + } else { + return this.getToken(ApexParser.LBRACK, i); + } + } + public RBRACK(): antlr.TerminalNode[]; + public RBRACK(i: number): antlr.TerminalNode | null; + public RBRACK(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { + if (i === undefined) { + return this.getTokens(ApexParser.RBRACK); + } else { + return this.getToken(ApexParser.RBRACK, i); + } + } + public override get ruleIndex(): number { + return ApexParser.RULE_arraySubscripts; + } + public override enterRule(listener: ApexParserListener): void { + if(listener.enterArraySubscripts) { + listener.enterArraySubscripts(this); + } + } + public override exitRule(listener: ApexParserListener): void { + if(listener.exitArraySubscripts) { + listener.exitArraySubscripts(this); + } + } + public override accept(visitor: ApexParserVisitor): Result | null { + if (visitor.visitArraySubscripts) { + return visitor.visitArraySubscripts(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class TypeNameContext extends antlr.ParserRuleContext { + public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { + super(parent, invokingState); + } + public LIST(): antlr.TerminalNode | null { + return this.getToken(ApexParser.LIST, 0); + } + public typeArguments(): TypeArgumentsContext | null { + return this.getRuleContext(0, TypeArgumentsContext); + } + public SET(): antlr.TerminalNode | null { + return this.getToken(ApexParser.SET, 0); + } + public MAP(): antlr.TerminalNode | null { + return this.getToken(ApexParser.MAP, 0); + } + public id(): IdContext | null { + return this.getRuleContext(0, IdContext); + } + public override get ruleIndex(): number { + return ApexParser.RULE_typeName; + } + public override enterRule(listener: ApexParserListener): void { + if(listener.enterTypeName) { + listener.enterTypeName(this); + } + } + public override exitRule(listener: ApexParserListener): void { + if(listener.exitTypeName) { + listener.exitTypeName(this); + } + } + public override accept(visitor: ApexParserVisitor): Result | null { + if (visitor.visitTypeName) { + return visitor.visitTypeName(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class TypeArgumentsContext extends antlr.ParserRuleContext { + public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { + super(parent, invokingState); + } + public LT(): antlr.TerminalNode { + return this.getToken(ApexParser.LT, 0)!; + } + public typeList(): TypeListContext { + return this.getRuleContext(0, TypeListContext)!; + } + public GT(): antlr.TerminalNode { + return this.getToken(ApexParser.GT, 0)!; + } + public override get ruleIndex(): number { + return ApexParser.RULE_typeArguments; + } + public override enterRule(listener: ApexParserListener): void { + if(listener.enterTypeArguments) { + listener.enterTypeArguments(this); + } + } + public override exitRule(listener: ApexParserListener): void { + if(listener.exitTypeArguments) { + listener.exitTypeArguments(this); + } + } + public override accept(visitor: ApexParserVisitor): Result | null { + if (visitor.visitTypeArguments) { + return visitor.visitTypeArguments(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class FormalParametersContext extends antlr.ParserRuleContext { + public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { + super(parent, invokingState); + } + public LPAREN(): antlr.TerminalNode { + return this.getToken(ApexParser.LPAREN, 0)!; + } + public RPAREN(): antlr.TerminalNode { + return this.getToken(ApexParser.RPAREN, 0)!; + } + public formalParameterList(): FormalParameterListContext | null { + return this.getRuleContext(0, FormalParameterListContext); + } + public override get ruleIndex(): number { + return ApexParser.RULE_formalParameters; + } + public override enterRule(listener: ApexParserListener): void { + if(listener.enterFormalParameters) { + listener.enterFormalParameters(this); + } + } + public override exitRule(listener: ApexParserListener): void { + if(listener.exitFormalParameters) { + listener.exitFormalParameters(this); + } + } + public override accept(visitor: ApexParserVisitor): Result | null { + if (visitor.visitFormalParameters) { + return visitor.visitFormalParameters(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class FormalParameterListContext extends antlr.ParserRuleContext { + public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { + super(parent, invokingState); + } + public formalParameter(): FormalParameterContext[]; + public formalParameter(i: number): FormalParameterContext | null; + public formalParameter(i?: number): FormalParameterContext[] | FormalParameterContext | null { + if (i === undefined) { + return this.getRuleContexts(FormalParameterContext); + } + + return this.getRuleContext(i, FormalParameterContext); + } + public COMMA(): antlr.TerminalNode[]; + public COMMA(i: number): antlr.TerminalNode | null; + public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { + if (i === undefined) { + return this.getTokens(ApexParser.COMMA); + } else { + return this.getToken(ApexParser.COMMA, i); + } + } + public override get ruleIndex(): number { + return ApexParser.RULE_formalParameterList; + } + public override enterRule(listener: ApexParserListener): void { + if(listener.enterFormalParameterList) { + listener.enterFormalParameterList(this); + } + } + public override exitRule(listener: ApexParserListener): void { + if(listener.exitFormalParameterList) { + listener.exitFormalParameterList(this); + } + } + public override accept(visitor: ApexParserVisitor): Result | null { + if (visitor.visitFormalParameterList) { + return visitor.visitFormalParameterList(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class FormalParameterContext extends antlr.ParserRuleContext { + public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { + super(parent, invokingState); + } + public typeRef(): TypeRefContext { + return this.getRuleContext(0, TypeRefContext)!; + } + public id(): IdContext { + return this.getRuleContext(0, IdContext)!; + } + public modifier(): ModifierContext[]; + public modifier(i: number): ModifierContext | null; + public modifier(i?: number): ModifierContext[] | ModifierContext | null { + if (i === undefined) { + return this.getRuleContexts(ModifierContext); + } + + return this.getRuleContext(i, ModifierContext); + } + public override get ruleIndex(): number { + return ApexParser.RULE_formalParameter; + } + public override enterRule(listener: ApexParserListener): void { + if(listener.enterFormalParameter) { + listener.enterFormalParameter(this); + } + } + public override exitRule(listener: ApexParserListener): void { + if(listener.exitFormalParameter) { + listener.exitFormalParameter(this); + } + } + public override accept(visitor: ApexParserVisitor): Result | null { + if (visitor.visitFormalParameter) { + return visitor.visitFormalParameter(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class QualifiedNameContext extends antlr.ParserRuleContext { + public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { + super(parent, invokingState); + } + public id(): IdContext[]; + public id(i: number): IdContext | null; + public id(i?: number): IdContext[] | IdContext | null { + if (i === undefined) { + return this.getRuleContexts(IdContext); + } + + return this.getRuleContext(i, IdContext); + } + public DOT(): antlr.TerminalNode[]; + public DOT(i: number): antlr.TerminalNode | null; + public DOT(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { + if (i === undefined) { + return this.getTokens(ApexParser.DOT); + } else { + return this.getToken(ApexParser.DOT, i); + } + } + public override get ruleIndex(): number { + return ApexParser.RULE_qualifiedName; + } + public override enterRule(listener: ApexParserListener): void { + if(listener.enterQualifiedName) { + listener.enterQualifiedName(this); + } + } + public override exitRule(listener: ApexParserListener): void { + if(listener.exitQualifiedName) { + listener.exitQualifiedName(this); + } + } + public override accept(visitor: ApexParserVisitor): Result | null { + if (visitor.visitQualifiedName) { + return visitor.visitQualifiedName(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class LiteralContext extends antlr.ParserRuleContext { + public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { + super(parent, invokingState); + } + public IntegerLiteral(): antlr.TerminalNode | null { + return this.getToken(ApexParser.IntegerLiteral, 0); + } + public LongLiteral(): antlr.TerminalNode | null { + return this.getToken(ApexParser.LongLiteral, 0); + } + public NumberLiteral(): antlr.TerminalNode | null { + return this.getToken(ApexParser.NumberLiteral, 0); + } + public StringLiteral(): antlr.TerminalNode | null { + return this.getToken(ApexParser.StringLiteral, 0); + } + public BooleanLiteral(): antlr.TerminalNode | null { + return this.getToken(ApexParser.BooleanLiteral, 0); + } + public NULL(): antlr.TerminalNode | null { + return this.getToken(ApexParser.NULL, 0); + } + public override get ruleIndex(): number { + return ApexParser.RULE_literal; + } + public override enterRule(listener: ApexParserListener): void { + if(listener.enterLiteral) { + listener.enterLiteral(this); + } + } + public override exitRule(listener: ApexParserListener): void { + if(listener.exitLiteral) { + listener.exitLiteral(this); + } + } + public override accept(visitor: ApexParserVisitor): Result | null { + if (visitor.visitLiteral) { + return visitor.visitLiteral(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class AnnotationContext extends antlr.ParserRuleContext { + public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { + super(parent, invokingState); + } + public ATSIGN(): antlr.TerminalNode { + return this.getToken(ApexParser.ATSIGN, 0)!; + } + public qualifiedName(): QualifiedNameContext { + return this.getRuleContext(0, QualifiedNameContext)!; + } + public LPAREN(): antlr.TerminalNode | null { + return this.getToken(ApexParser.LPAREN, 0); + } + public RPAREN(): antlr.TerminalNode | null { + return this.getToken(ApexParser.RPAREN, 0); + } + public elementValuePairs(): ElementValuePairsContext | null { + return this.getRuleContext(0, ElementValuePairsContext); + } + public elementValue(): ElementValueContext | null { + return this.getRuleContext(0, ElementValueContext); + } + public override get ruleIndex(): number { + return ApexParser.RULE_annotation; + } + public override enterRule(listener: ApexParserListener): void { + if(listener.enterAnnotation) { + listener.enterAnnotation(this); + } + } + public override exitRule(listener: ApexParserListener): void { + if(listener.exitAnnotation) { + listener.exitAnnotation(this); + } + } + public override accept(visitor: ApexParserVisitor): Result | null { + if (visitor.visitAnnotation) { + return visitor.visitAnnotation(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class ElementValuePairsContext extends antlr.ParserRuleContext { + public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { + super(parent, invokingState); + } + public elementValuePair(): ElementValuePairContext[]; + public elementValuePair(i: number): ElementValuePairContext | null; + public elementValuePair(i?: number): ElementValuePairContext[] | ElementValuePairContext | null { + if (i === undefined) { + return this.getRuleContexts(ElementValuePairContext); + } + + return this.getRuleContext(i, ElementValuePairContext); + } + public COMMA(): antlr.TerminalNode[]; + public COMMA(i: number): antlr.TerminalNode | null; + public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { + if (i === undefined) { + return this.getTokens(ApexParser.COMMA); + } else { + return this.getToken(ApexParser.COMMA, i); + } + } + public override get ruleIndex(): number { + return ApexParser.RULE_elementValuePairs; + } + public override enterRule(listener: ApexParserListener): void { + if(listener.enterElementValuePairs) { + listener.enterElementValuePairs(this); + } + } + public override exitRule(listener: ApexParserListener): void { + if(listener.exitElementValuePairs) { + listener.exitElementValuePairs(this); + } + } + public override accept(visitor: ApexParserVisitor): Result | null { + if (visitor.visitElementValuePairs) { + return visitor.visitElementValuePairs(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class ElementValuePairContext extends antlr.ParserRuleContext { + public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { + super(parent, invokingState); + } + public id(): IdContext { + return this.getRuleContext(0, IdContext)!; + } + public ASSIGN(): antlr.TerminalNode { + return this.getToken(ApexParser.ASSIGN, 0)!; + } + public elementValue(): ElementValueContext { + return this.getRuleContext(0, ElementValueContext)!; + } + public override get ruleIndex(): number { + return ApexParser.RULE_elementValuePair; + } + public override enterRule(listener: ApexParserListener): void { + if(listener.enterElementValuePair) { + listener.enterElementValuePair(this); + } + } + public override exitRule(listener: ApexParserListener): void { + if(listener.exitElementValuePair) { + listener.exitElementValuePair(this); + } + } + public override accept(visitor: ApexParserVisitor): Result | null { + if (visitor.visitElementValuePair) { + return visitor.visitElementValuePair(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class ElementValueContext extends antlr.ParserRuleContext { + public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { + super(parent, invokingState); + } + public expression(): ExpressionContext | null { + return this.getRuleContext(0, ExpressionContext); + } + public annotation(): AnnotationContext | null { + return this.getRuleContext(0, AnnotationContext); + } + public elementValueArrayInitializer(): ElementValueArrayInitializerContext | null { + return this.getRuleContext(0, ElementValueArrayInitializerContext); + } + public override get ruleIndex(): number { + return ApexParser.RULE_elementValue; + } + public override enterRule(listener: ApexParserListener): void { + if(listener.enterElementValue) { + listener.enterElementValue(this); + } + } + public override exitRule(listener: ApexParserListener): void { + if(listener.exitElementValue) { + listener.exitElementValue(this); + } + } + public override accept(visitor: ApexParserVisitor): Result | null { + if (visitor.visitElementValue) { + return visitor.visitElementValue(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class ElementValueArrayInitializerContext extends antlr.ParserRuleContext { + public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { + super(parent, invokingState); + } + public LBRACE(): antlr.TerminalNode { + return this.getToken(ApexParser.LBRACE, 0)!; + } + public RBRACE(): antlr.TerminalNode { + return this.getToken(ApexParser.RBRACE, 0)!; + } + public elementValue(): ElementValueContext[]; + public elementValue(i: number): ElementValueContext | null; + public elementValue(i?: number): ElementValueContext[] | ElementValueContext | null { + if (i === undefined) { + return this.getRuleContexts(ElementValueContext); + } + + return this.getRuleContext(i, ElementValueContext); + } + public COMMA(): antlr.TerminalNode[]; + public COMMA(i: number): antlr.TerminalNode | null; + public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { + if (i === undefined) { + return this.getTokens(ApexParser.COMMA); + } else { + return this.getToken(ApexParser.COMMA, i); + } + } + public override get ruleIndex(): number { + return ApexParser.RULE_elementValueArrayInitializer; + } + public override enterRule(listener: ApexParserListener): void { + if(listener.enterElementValueArrayInitializer) { + listener.enterElementValueArrayInitializer(this); + } + } + public override exitRule(listener: ApexParserListener): void { + if(listener.exitElementValueArrayInitializer) { + listener.exitElementValueArrayInitializer(this); + } + } + public override accept(visitor: ApexParserVisitor): Result | null { + if (visitor.visitElementValueArrayInitializer) { + return visitor.visitElementValueArrayInitializer(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class BlockContext extends antlr.ParserRuleContext { + public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { + super(parent, invokingState); + } + public LBRACE(): antlr.TerminalNode { + return this.getToken(ApexParser.LBRACE, 0)!; + } + public RBRACE(): antlr.TerminalNode { + return this.getToken(ApexParser.RBRACE, 0)!; + } + public statement(): StatementContext[]; + public statement(i: number): StatementContext | null; + public statement(i?: number): StatementContext[] | StatementContext | null { + if (i === undefined) { + return this.getRuleContexts(StatementContext); + } + + return this.getRuleContext(i, StatementContext); + } + public override get ruleIndex(): number { + return ApexParser.RULE_block; + } + public override enterRule(listener: ApexParserListener): void { + if(listener.enterBlock) { + listener.enterBlock(this); + } + } + public override exitRule(listener: ApexParserListener): void { + if(listener.exitBlock) { + listener.exitBlock(this); + } + } + public override accept(visitor: ApexParserVisitor): Result | null { + if (visitor.visitBlock) { + return visitor.visitBlock(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class LocalVariableDeclarationStatementContext extends antlr.ParserRuleContext { + public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { + super(parent, invokingState); + } + public localVariableDeclaration(): LocalVariableDeclarationContext { + return this.getRuleContext(0, LocalVariableDeclarationContext)!; + } + public SEMI(): antlr.TerminalNode { + return this.getToken(ApexParser.SEMI, 0)!; + } + public override get ruleIndex(): number { + return ApexParser.RULE_localVariableDeclarationStatement; + } + public override enterRule(listener: ApexParserListener): void { + if(listener.enterLocalVariableDeclarationStatement) { + listener.enterLocalVariableDeclarationStatement(this); + } + } + public override exitRule(listener: ApexParserListener): void { + if(listener.exitLocalVariableDeclarationStatement) { + listener.exitLocalVariableDeclarationStatement(this); + } + } + public override accept(visitor: ApexParserVisitor): Result | null { + if (visitor.visitLocalVariableDeclarationStatement) { + return visitor.visitLocalVariableDeclarationStatement(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class LocalVariableDeclarationContext extends antlr.ParserRuleContext { + public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { + super(parent, invokingState); + } + public typeRef(): TypeRefContext { + return this.getRuleContext(0, TypeRefContext)!; + } + public variableDeclarators(): VariableDeclaratorsContext { + return this.getRuleContext(0, VariableDeclaratorsContext)!; + } + public modifier(): ModifierContext[]; + public modifier(i: number): ModifierContext | null; + public modifier(i?: number): ModifierContext[] | ModifierContext | null { + if (i === undefined) { + return this.getRuleContexts(ModifierContext); + } + + return this.getRuleContext(i, ModifierContext); + } + public override get ruleIndex(): number { + return ApexParser.RULE_localVariableDeclaration; + } + public override enterRule(listener: ApexParserListener): void { + if(listener.enterLocalVariableDeclaration) { + listener.enterLocalVariableDeclaration(this); + } + } + public override exitRule(listener: ApexParserListener): void { + if(listener.exitLocalVariableDeclaration) { + listener.exitLocalVariableDeclaration(this); + } + } + public override accept(visitor: ApexParserVisitor): Result | null { + if (visitor.visitLocalVariableDeclaration) { + return visitor.visitLocalVariableDeclaration(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class StatementContext extends antlr.ParserRuleContext { + public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { + super(parent, invokingState); + } + public block(): BlockContext | null { + return this.getRuleContext(0, BlockContext); + } + public ifStatement(): IfStatementContext | null { + return this.getRuleContext(0, IfStatementContext); + } + public switchStatement(): SwitchStatementContext | null { + return this.getRuleContext(0, SwitchStatementContext); + } + public forStatement(): ForStatementContext | null { + return this.getRuleContext(0, ForStatementContext); + } + public whileStatement(): WhileStatementContext | null { + return this.getRuleContext(0, WhileStatementContext); + } + public doWhileStatement(): DoWhileStatementContext | null { + return this.getRuleContext(0, DoWhileStatementContext); + } + public tryStatement(): TryStatementContext | null { + return this.getRuleContext(0, TryStatementContext); + } + public returnStatement(): ReturnStatementContext | null { + return this.getRuleContext(0, ReturnStatementContext); + } + public throwStatement(): ThrowStatementContext | null { + return this.getRuleContext(0, ThrowStatementContext); + } + public breakStatement(): BreakStatementContext | null { + return this.getRuleContext(0, BreakStatementContext); + } + public continueStatement(): ContinueStatementContext | null { + return this.getRuleContext(0, ContinueStatementContext); + } + public insertStatement(): InsertStatementContext | null { + return this.getRuleContext(0, InsertStatementContext); + } + public updateStatement(): UpdateStatementContext | null { + return this.getRuleContext(0, UpdateStatementContext); + } + public deleteStatement(): DeleteStatementContext | null { + return this.getRuleContext(0, DeleteStatementContext); + } + public undeleteStatement(): UndeleteStatementContext | null { + return this.getRuleContext(0, UndeleteStatementContext); + } + public upsertStatement(): UpsertStatementContext | null { + return this.getRuleContext(0, UpsertStatementContext); + } + public mergeStatement(): MergeStatementContext | null { + return this.getRuleContext(0, MergeStatementContext); + } + public runAsStatement(): RunAsStatementContext | null { + return this.getRuleContext(0, RunAsStatementContext); + } + public localVariableDeclarationStatement(): LocalVariableDeclarationStatementContext | null { + return this.getRuleContext(0, LocalVariableDeclarationStatementContext); + } + public expressionStatement(): ExpressionStatementContext | null { + return this.getRuleContext(0, ExpressionStatementContext); + } + public override get ruleIndex(): number { + return ApexParser.RULE_statement; + } + public override enterRule(listener: ApexParserListener): void { + if(listener.enterStatement) { + listener.enterStatement(this); + } + } + public override exitRule(listener: ApexParserListener): void { + if(listener.exitStatement) { + listener.exitStatement(this); + } + } + public override accept(visitor: ApexParserVisitor): Result | null { + if (visitor.visitStatement) { + return visitor.visitStatement(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class IfStatementContext extends antlr.ParserRuleContext { + public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { + super(parent, invokingState); + } + public IF(): antlr.TerminalNode { + return this.getToken(ApexParser.IF, 0)!; + } + public parExpression(): ParExpressionContext { + return this.getRuleContext(0, ParExpressionContext)!; + } + public statement(): StatementContext[]; + public statement(i: number): StatementContext | null; + public statement(i?: number): StatementContext[] | StatementContext | null { + if (i === undefined) { + return this.getRuleContexts(StatementContext); + } + + return this.getRuleContext(i, StatementContext); + } + public ELSE(): antlr.TerminalNode | null { + return this.getToken(ApexParser.ELSE, 0); + } + public override get ruleIndex(): number { + return ApexParser.RULE_ifStatement; + } + public override enterRule(listener: ApexParserListener): void { + if(listener.enterIfStatement) { + listener.enterIfStatement(this); + } + } + public override exitRule(listener: ApexParserListener): void { + if(listener.exitIfStatement) { + listener.exitIfStatement(this); + } + } + public override accept(visitor: ApexParserVisitor): Result | null { + if (visitor.visitIfStatement) { + return visitor.visitIfStatement(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class SwitchStatementContext extends antlr.ParserRuleContext { + public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { + super(parent, invokingState); + } + public SWITCH(): antlr.TerminalNode { + return this.getToken(ApexParser.SWITCH, 0)!; + } + public ON(): antlr.TerminalNode { + return this.getToken(ApexParser.ON, 0)!; + } + public expression(): ExpressionContext { + return this.getRuleContext(0, ExpressionContext)!; + } + public LBRACE(): antlr.TerminalNode { + return this.getToken(ApexParser.LBRACE, 0)!; + } + public RBRACE(): antlr.TerminalNode { + return this.getToken(ApexParser.RBRACE, 0)!; + } + public whenControl(): WhenControlContext[]; + public whenControl(i: number): WhenControlContext | null; + public whenControl(i?: number): WhenControlContext[] | WhenControlContext | null { + if (i === undefined) { + return this.getRuleContexts(WhenControlContext); + } + + return this.getRuleContext(i, WhenControlContext); + } + public override get ruleIndex(): number { + return ApexParser.RULE_switchStatement; + } + public override enterRule(listener: ApexParserListener): void { + if(listener.enterSwitchStatement) { + listener.enterSwitchStatement(this); + } + } + public override exitRule(listener: ApexParserListener): void { + if(listener.exitSwitchStatement) { + listener.exitSwitchStatement(this); + } + } + public override accept(visitor: ApexParserVisitor): Result | null { + if (visitor.visitSwitchStatement) { + return visitor.visitSwitchStatement(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class WhenControlContext extends antlr.ParserRuleContext { + public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { + super(parent, invokingState); + } + public WHEN(): antlr.TerminalNode { + return this.getToken(ApexParser.WHEN, 0)!; + } + public whenValue(): WhenValueContext { + return this.getRuleContext(0, WhenValueContext)!; + } + public block(): BlockContext { + return this.getRuleContext(0, BlockContext)!; + } + public override get ruleIndex(): number { + return ApexParser.RULE_whenControl; + } + public override enterRule(listener: ApexParserListener): void { + if(listener.enterWhenControl) { + listener.enterWhenControl(this); + } + } + public override exitRule(listener: ApexParserListener): void { + if(listener.exitWhenControl) { + listener.exitWhenControl(this); + } + } + public override accept(visitor: ApexParserVisitor): Result | null { + if (visitor.visitWhenControl) { + return visitor.visitWhenControl(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class WhenValueContext extends antlr.ParserRuleContext { + public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { + super(parent, invokingState); + } + public ELSE(): antlr.TerminalNode | null { + return this.getToken(ApexParser.ELSE, 0); + } + public whenLiteral(): WhenLiteralContext[]; + public whenLiteral(i: number): WhenLiteralContext | null; + public whenLiteral(i?: number): WhenLiteralContext[] | WhenLiteralContext | null { + if (i === undefined) { + return this.getRuleContexts(WhenLiteralContext); + } + + return this.getRuleContext(i, WhenLiteralContext); + } + public COMMA(): antlr.TerminalNode[]; + public COMMA(i: number): antlr.TerminalNode | null; + public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { + if (i === undefined) { + return this.getTokens(ApexParser.COMMA); + } else { + return this.getToken(ApexParser.COMMA, i); + } + } + public id(): IdContext[]; + public id(i: number): IdContext | null; + public id(i?: number): IdContext[] | IdContext | null { + if (i === undefined) { + return this.getRuleContexts(IdContext); + } + + return this.getRuleContext(i, IdContext); + } + public override get ruleIndex(): number { + return ApexParser.RULE_whenValue; + } + public override enterRule(listener: ApexParserListener): void { + if(listener.enterWhenValue) { + listener.enterWhenValue(this); + } + } + public override exitRule(listener: ApexParserListener): void { + if(listener.exitWhenValue) { + listener.exitWhenValue(this); + } + } + public override accept(visitor: ApexParserVisitor): Result | null { + if (visitor.visitWhenValue) { + return visitor.visitWhenValue(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class WhenLiteralContext extends antlr.ParserRuleContext { + public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { + super(parent, invokingState); + } + public IntegerLiteral(): antlr.TerminalNode | null { + return this.getToken(ApexParser.IntegerLiteral, 0); + } + public SUB(): antlr.TerminalNode | null { + return this.getToken(ApexParser.SUB, 0); + } + public LongLiteral(): antlr.TerminalNode | null { + return this.getToken(ApexParser.LongLiteral, 0); + } + public StringLiteral(): antlr.TerminalNode | null { + return this.getToken(ApexParser.StringLiteral, 0); + } + public NULL(): antlr.TerminalNode | null { + return this.getToken(ApexParser.NULL, 0); + } + public id(): IdContext | null { + return this.getRuleContext(0, IdContext); + } + public LPAREN(): antlr.TerminalNode | null { + return this.getToken(ApexParser.LPAREN, 0); + } + public whenLiteral(): WhenLiteralContext | null { + return this.getRuleContext(0, WhenLiteralContext); + } + public RPAREN(): antlr.TerminalNode | null { + return this.getToken(ApexParser.RPAREN, 0); + } + public override get ruleIndex(): number { + return ApexParser.RULE_whenLiteral; + } + public override enterRule(listener: ApexParserListener): void { + if(listener.enterWhenLiteral) { + listener.enterWhenLiteral(this); + } + } + public override exitRule(listener: ApexParserListener): void { + if(listener.exitWhenLiteral) { + listener.exitWhenLiteral(this); + } + } + public override accept(visitor: ApexParserVisitor): Result | null { + if (visitor.visitWhenLiteral) { + return visitor.visitWhenLiteral(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class ForStatementContext extends antlr.ParserRuleContext { + public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { + super(parent, invokingState); + } + public FOR(): antlr.TerminalNode { + return this.getToken(ApexParser.FOR, 0)!; + } + public LPAREN(): antlr.TerminalNode { + return this.getToken(ApexParser.LPAREN, 0)!; + } + public forControl(): ForControlContext { + return this.getRuleContext(0, ForControlContext)!; + } + public RPAREN(): antlr.TerminalNode { + return this.getToken(ApexParser.RPAREN, 0)!; + } + public statement(): StatementContext | null { + return this.getRuleContext(0, StatementContext); + } + public SEMI(): antlr.TerminalNode | null { + return this.getToken(ApexParser.SEMI, 0); + } + public override get ruleIndex(): number { + return ApexParser.RULE_forStatement; + } + public override enterRule(listener: ApexParserListener): void { + if(listener.enterForStatement) { + listener.enterForStatement(this); + } + } + public override exitRule(listener: ApexParserListener): void { + if(listener.exitForStatement) { + listener.exitForStatement(this); + } + } + public override accept(visitor: ApexParserVisitor): Result | null { + if (visitor.visitForStatement) { + return visitor.visitForStatement(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class WhileStatementContext extends antlr.ParserRuleContext { + public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { + super(parent, invokingState); + } + public WHILE(): antlr.TerminalNode { + return this.getToken(ApexParser.WHILE, 0)!; + } + public parExpression(): ParExpressionContext { + return this.getRuleContext(0, ParExpressionContext)!; + } + public statement(): StatementContext | null { + return this.getRuleContext(0, StatementContext); + } + public SEMI(): antlr.TerminalNode | null { + return this.getToken(ApexParser.SEMI, 0); + } + public override get ruleIndex(): number { + return ApexParser.RULE_whileStatement; + } + public override enterRule(listener: ApexParserListener): void { + if(listener.enterWhileStatement) { + listener.enterWhileStatement(this); + } + } + public override exitRule(listener: ApexParserListener): void { + if(listener.exitWhileStatement) { + listener.exitWhileStatement(this); + } + } + public override accept(visitor: ApexParserVisitor): Result | null { + if (visitor.visitWhileStatement) { + return visitor.visitWhileStatement(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class DoWhileStatementContext extends antlr.ParserRuleContext { + public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { + super(parent, invokingState); + } + public DO(): antlr.TerminalNode { + return this.getToken(ApexParser.DO, 0)!; + } + public statement(): StatementContext { + return this.getRuleContext(0, StatementContext)!; + } + public WHILE(): antlr.TerminalNode { + return this.getToken(ApexParser.WHILE, 0)!; + } + public parExpression(): ParExpressionContext { + return this.getRuleContext(0, ParExpressionContext)!; + } + public SEMI(): antlr.TerminalNode { + return this.getToken(ApexParser.SEMI, 0)!; + } + public override get ruleIndex(): number { + return ApexParser.RULE_doWhileStatement; + } + public override enterRule(listener: ApexParserListener): void { + if(listener.enterDoWhileStatement) { + listener.enterDoWhileStatement(this); + } + } + public override exitRule(listener: ApexParserListener): void { + if(listener.exitDoWhileStatement) { + listener.exitDoWhileStatement(this); + } + } + public override accept(visitor: ApexParserVisitor): Result | null { + if (visitor.visitDoWhileStatement) { + return visitor.visitDoWhileStatement(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class TryStatementContext extends antlr.ParserRuleContext { + public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { + super(parent, invokingState); + } + public TRY(): antlr.TerminalNode { + return this.getToken(ApexParser.TRY, 0)!; + } + public block(): BlockContext { + return this.getRuleContext(0, BlockContext)!; + } + public finallyBlock(): FinallyBlockContext | null { + return this.getRuleContext(0, FinallyBlockContext); + } + public catchClause(): CatchClauseContext[]; + public catchClause(i: number): CatchClauseContext | null; + public catchClause(i?: number): CatchClauseContext[] | CatchClauseContext | null { + if (i === undefined) { + return this.getRuleContexts(CatchClauseContext); + } + + return this.getRuleContext(i, CatchClauseContext); + } + public override get ruleIndex(): number { + return ApexParser.RULE_tryStatement; + } + public override enterRule(listener: ApexParserListener): void { + if(listener.enterTryStatement) { + listener.enterTryStatement(this); + } + } + public override exitRule(listener: ApexParserListener): void { + if(listener.exitTryStatement) { + listener.exitTryStatement(this); + } + } + public override accept(visitor: ApexParserVisitor): Result | null { + if (visitor.visitTryStatement) { + return visitor.visitTryStatement(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class ReturnStatementContext extends antlr.ParserRuleContext { + public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { + super(parent, invokingState); + } + public RETURN(): antlr.TerminalNode { + return this.getToken(ApexParser.RETURN, 0)!; + } + public SEMI(): antlr.TerminalNode { + return this.getToken(ApexParser.SEMI, 0)!; + } + public expression(): ExpressionContext | null { + return this.getRuleContext(0, ExpressionContext); + } + public override get ruleIndex(): number { + return ApexParser.RULE_returnStatement; + } + public override enterRule(listener: ApexParserListener): void { + if(listener.enterReturnStatement) { + listener.enterReturnStatement(this); + } + } + public override exitRule(listener: ApexParserListener): void { + if(listener.exitReturnStatement) { + listener.exitReturnStatement(this); + } + } + public override accept(visitor: ApexParserVisitor): Result | null { + if (visitor.visitReturnStatement) { + return visitor.visitReturnStatement(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class ThrowStatementContext extends antlr.ParserRuleContext { + public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { + super(parent, invokingState); + } + public THROW(): antlr.TerminalNode { + return this.getToken(ApexParser.THROW, 0)!; + } + public expression(): ExpressionContext { + return this.getRuleContext(0, ExpressionContext)!; + } + public SEMI(): antlr.TerminalNode { + return this.getToken(ApexParser.SEMI, 0)!; + } + public override get ruleIndex(): number { + return ApexParser.RULE_throwStatement; + } + public override enterRule(listener: ApexParserListener): void { + if(listener.enterThrowStatement) { + listener.enterThrowStatement(this); + } + } + public override exitRule(listener: ApexParserListener): void { + if(listener.exitThrowStatement) { + listener.exitThrowStatement(this); + } + } + public override accept(visitor: ApexParserVisitor): Result | null { + if (visitor.visitThrowStatement) { + return visitor.visitThrowStatement(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class BreakStatementContext extends antlr.ParserRuleContext { + public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { + super(parent, invokingState); + } + public BREAK(): antlr.TerminalNode { + return this.getToken(ApexParser.BREAK, 0)!; + } + public SEMI(): antlr.TerminalNode { + return this.getToken(ApexParser.SEMI, 0)!; + } + public override get ruleIndex(): number { + return ApexParser.RULE_breakStatement; + } + public override enterRule(listener: ApexParserListener): void { + if(listener.enterBreakStatement) { + listener.enterBreakStatement(this); + } + } + public override exitRule(listener: ApexParserListener): void { + if(listener.exitBreakStatement) { + listener.exitBreakStatement(this); + } + } + public override accept(visitor: ApexParserVisitor): Result | null { + if (visitor.visitBreakStatement) { + return visitor.visitBreakStatement(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class ContinueStatementContext extends antlr.ParserRuleContext { + public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { + super(parent, invokingState); + } + public CONTINUE(): antlr.TerminalNode { + return this.getToken(ApexParser.CONTINUE, 0)!; + } + public SEMI(): antlr.TerminalNode { + return this.getToken(ApexParser.SEMI, 0)!; + } + public override get ruleIndex(): number { + return ApexParser.RULE_continueStatement; + } + public override enterRule(listener: ApexParserListener): void { + if(listener.enterContinueStatement) { + listener.enterContinueStatement(this); + } + } + public override exitRule(listener: ApexParserListener): void { + if(listener.exitContinueStatement) { + listener.exitContinueStatement(this); + } + } + public override accept(visitor: ApexParserVisitor): Result | null { + if (visitor.visitContinueStatement) { + return visitor.visitContinueStatement(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class AccessLevelContext extends antlr.ParserRuleContext { + public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { + super(parent, invokingState); + } + public AS(): antlr.TerminalNode { + return this.getToken(ApexParser.AS, 0)!; + } + public SYSTEM(): antlr.TerminalNode | null { + return this.getToken(ApexParser.SYSTEM, 0); + } + public USER(): antlr.TerminalNode | null { + return this.getToken(ApexParser.USER, 0); + } + public override get ruleIndex(): number { + return ApexParser.RULE_accessLevel; + } + public override enterRule(listener: ApexParserListener): void { + if(listener.enterAccessLevel) { + listener.enterAccessLevel(this); + } + } + public override exitRule(listener: ApexParserListener): void { + if(listener.exitAccessLevel) { + listener.exitAccessLevel(this); + } + } + public override accept(visitor: ApexParserVisitor): Result | null { + if (visitor.visitAccessLevel) { + return visitor.visitAccessLevel(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class InsertStatementContext extends antlr.ParserRuleContext { + public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { + super(parent, invokingState); + } + public INSERT(): antlr.TerminalNode { + return this.getToken(ApexParser.INSERT, 0)!; + } + public expression(): ExpressionContext { + return this.getRuleContext(0, ExpressionContext)!; + } + public SEMI(): antlr.TerminalNode { + return this.getToken(ApexParser.SEMI, 0)!; + } + public accessLevel(): AccessLevelContext | null { + return this.getRuleContext(0, AccessLevelContext); + } + public override get ruleIndex(): number { + return ApexParser.RULE_insertStatement; + } + public override enterRule(listener: ApexParserListener): void { + if(listener.enterInsertStatement) { + listener.enterInsertStatement(this); + } + } + public override exitRule(listener: ApexParserListener): void { + if(listener.exitInsertStatement) { + listener.exitInsertStatement(this); + } + } + public override accept(visitor: ApexParserVisitor): Result | null { + if (visitor.visitInsertStatement) { + return visitor.visitInsertStatement(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class UpdateStatementContext extends antlr.ParserRuleContext { + public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { + super(parent, invokingState); + } + public UPDATE(): antlr.TerminalNode { + return this.getToken(ApexParser.UPDATE, 0)!; + } + public expression(): ExpressionContext { + return this.getRuleContext(0, ExpressionContext)!; + } + public SEMI(): antlr.TerminalNode { + return this.getToken(ApexParser.SEMI, 0)!; + } + public accessLevel(): AccessLevelContext | null { + return this.getRuleContext(0, AccessLevelContext); + } + public override get ruleIndex(): number { + return ApexParser.RULE_updateStatement; + } + public override enterRule(listener: ApexParserListener): void { + if(listener.enterUpdateStatement) { + listener.enterUpdateStatement(this); + } + } + public override exitRule(listener: ApexParserListener): void { + if(listener.exitUpdateStatement) { + listener.exitUpdateStatement(this); + } + } + public override accept(visitor: ApexParserVisitor): Result | null { + if (visitor.visitUpdateStatement) { + return visitor.visitUpdateStatement(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class DeleteStatementContext extends antlr.ParserRuleContext { + public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { + super(parent, invokingState); + } + public DELETE(): antlr.TerminalNode { + return this.getToken(ApexParser.DELETE, 0)!; + } + public expression(): ExpressionContext { + return this.getRuleContext(0, ExpressionContext)!; + } + public SEMI(): antlr.TerminalNode { + return this.getToken(ApexParser.SEMI, 0)!; + } + public accessLevel(): AccessLevelContext | null { + return this.getRuleContext(0, AccessLevelContext); + } + public override get ruleIndex(): number { + return ApexParser.RULE_deleteStatement; + } + public override enterRule(listener: ApexParserListener): void { + if(listener.enterDeleteStatement) { + listener.enterDeleteStatement(this); + } + } + public override exitRule(listener: ApexParserListener): void { + if(listener.exitDeleteStatement) { + listener.exitDeleteStatement(this); + } + } + public override accept(visitor: ApexParserVisitor): Result | null { + if (visitor.visitDeleteStatement) { + return visitor.visitDeleteStatement(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class UndeleteStatementContext extends antlr.ParserRuleContext { + public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { + super(parent, invokingState); + } + public UNDELETE(): antlr.TerminalNode { + return this.getToken(ApexParser.UNDELETE, 0)!; + } + public expression(): ExpressionContext { + return this.getRuleContext(0, ExpressionContext)!; + } + public SEMI(): antlr.TerminalNode { + return this.getToken(ApexParser.SEMI, 0)!; + } + public accessLevel(): AccessLevelContext | null { + return this.getRuleContext(0, AccessLevelContext); + } + public override get ruleIndex(): number { + return ApexParser.RULE_undeleteStatement; + } + public override enterRule(listener: ApexParserListener): void { + if(listener.enterUndeleteStatement) { + listener.enterUndeleteStatement(this); + } + } + public override exitRule(listener: ApexParserListener): void { + if(listener.exitUndeleteStatement) { + listener.exitUndeleteStatement(this); + } + } + public override accept(visitor: ApexParserVisitor): Result | null { + if (visitor.visitUndeleteStatement) { + return visitor.visitUndeleteStatement(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class UpsertStatementContext extends antlr.ParserRuleContext { + public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { + super(parent, invokingState); + } + public UPSERT(): antlr.TerminalNode { + return this.getToken(ApexParser.UPSERT, 0)!; + } + public expression(): ExpressionContext { + return this.getRuleContext(0, ExpressionContext)!; + } + public SEMI(): antlr.TerminalNode { + return this.getToken(ApexParser.SEMI, 0)!; + } + public accessLevel(): AccessLevelContext | null { + return this.getRuleContext(0, AccessLevelContext); + } + public qualifiedName(): QualifiedNameContext | null { + return this.getRuleContext(0, QualifiedNameContext); + } + public override get ruleIndex(): number { + return ApexParser.RULE_upsertStatement; + } + public override enterRule(listener: ApexParserListener): void { + if(listener.enterUpsertStatement) { + listener.enterUpsertStatement(this); + } + } + public override exitRule(listener: ApexParserListener): void { + if(listener.exitUpsertStatement) { + listener.exitUpsertStatement(this); + } + } + public override accept(visitor: ApexParserVisitor): Result | null { + if (visitor.visitUpsertStatement) { + return visitor.visitUpsertStatement(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class MergeStatementContext extends antlr.ParserRuleContext { + public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { + super(parent, invokingState); + } + public MERGE(): antlr.TerminalNode { + return this.getToken(ApexParser.MERGE, 0)!; + } + public expression(): ExpressionContext[]; + public expression(i: number): ExpressionContext | null; + public expression(i?: number): ExpressionContext[] | ExpressionContext | null { + if (i === undefined) { + return this.getRuleContexts(ExpressionContext); + } + + return this.getRuleContext(i, ExpressionContext); + } + public SEMI(): antlr.TerminalNode { + return this.getToken(ApexParser.SEMI, 0)!; + } + public accessLevel(): AccessLevelContext | null { + return this.getRuleContext(0, AccessLevelContext); + } + public override get ruleIndex(): number { + return ApexParser.RULE_mergeStatement; + } + public override enterRule(listener: ApexParserListener): void { + if(listener.enterMergeStatement) { + listener.enterMergeStatement(this); + } + } + public override exitRule(listener: ApexParserListener): void { + if(listener.exitMergeStatement) { + listener.exitMergeStatement(this); + } + } + public override accept(visitor: ApexParserVisitor): Result | null { + if (visitor.visitMergeStatement) { + return visitor.visitMergeStatement(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class RunAsStatementContext extends antlr.ParserRuleContext { + public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { + super(parent, invokingState); + } + public SYSTEMRUNAS(): antlr.TerminalNode { + return this.getToken(ApexParser.SYSTEMRUNAS, 0)!; + } + public LPAREN(): antlr.TerminalNode { + return this.getToken(ApexParser.LPAREN, 0)!; + } + public RPAREN(): antlr.TerminalNode { + return this.getToken(ApexParser.RPAREN, 0)!; + } + public block(): BlockContext { + return this.getRuleContext(0, BlockContext)!; + } + public expressionList(): ExpressionListContext | null { + return this.getRuleContext(0, ExpressionListContext); + } + public override get ruleIndex(): number { + return ApexParser.RULE_runAsStatement; + } + public override enterRule(listener: ApexParserListener): void { + if(listener.enterRunAsStatement) { + listener.enterRunAsStatement(this); + } + } + public override exitRule(listener: ApexParserListener): void { + if(listener.exitRunAsStatement) { + listener.exitRunAsStatement(this); + } + } + public override accept(visitor: ApexParserVisitor): Result | null { + if (visitor.visitRunAsStatement) { + return visitor.visitRunAsStatement(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class ExpressionStatementContext extends antlr.ParserRuleContext { + public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { + super(parent, invokingState); + } + public expression(): ExpressionContext { + return this.getRuleContext(0, ExpressionContext)!; + } + public SEMI(): antlr.TerminalNode { + return this.getToken(ApexParser.SEMI, 0)!; + } + public override get ruleIndex(): number { + return ApexParser.RULE_expressionStatement; + } + public override enterRule(listener: ApexParserListener): void { + if(listener.enterExpressionStatement) { + listener.enterExpressionStatement(this); + } + } + public override exitRule(listener: ApexParserListener): void { + if(listener.exitExpressionStatement) { + listener.exitExpressionStatement(this); + } + } + public override accept(visitor: ApexParserVisitor): Result | null { + if (visitor.visitExpressionStatement) { + return visitor.visitExpressionStatement(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class PropertyBlockContext extends antlr.ParserRuleContext { + public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { + super(parent, invokingState); + } + public getter(): GetterContext | null { + return this.getRuleContext(0, GetterContext); + } + public setter(): SetterContext | null { + return this.getRuleContext(0, SetterContext); + } + public modifier(): ModifierContext[]; + public modifier(i: number): ModifierContext | null; + public modifier(i?: number): ModifierContext[] | ModifierContext | null { + if (i === undefined) { + return this.getRuleContexts(ModifierContext); + } + + return this.getRuleContext(i, ModifierContext); + } + public override get ruleIndex(): number { + return ApexParser.RULE_propertyBlock; + } + public override enterRule(listener: ApexParserListener): void { + if(listener.enterPropertyBlock) { + listener.enterPropertyBlock(this); + } + } + public override exitRule(listener: ApexParserListener): void { + if(listener.exitPropertyBlock) { + listener.exitPropertyBlock(this); + } + } + public override accept(visitor: ApexParserVisitor): Result | null { + if (visitor.visitPropertyBlock) { + return visitor.visitPropertyBlock(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class GetterContext extends antlr.ParserRuleContext { + public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { + super(parent, invokingState); + } + public GET(): antlr.TerminalNode { + return this.getToken(ApexParser.GET, 0)!; + } + public SEMI(): antlr.TerminalNode | null { + return this.getToken(ApexParser.SEMI, 0); + } + public block(): BlockContext | null { + return this.getRuleContext(0, BlockContext); + } + public override get ruleIndex(): number { + return ApexParser.RULE_getter; + } + public override enterRule(listener: ApexParserListener): void { + if(listener.enterGetter) { + listener.enterGetter(this); + } + } + public override exitRule(listener: ApexParserListener): void { + if(listener.exitGetter) { + listener.exitGetter(this); + } + } + public override accept(visitor: ApexParserVisitor): Result | null { + if (visitor.visitGetter) { + return visitor.visitGetter(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class SetterContext extends antlr.ParserRuleContext { + public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { + super(parent, invokingState); + } + public SET(): antlr.TerminalNode { + return this.getToken(ApexParser.SET, 0)!; + } + public SEMI(): antlr.TerminalNode | null { + return this.getToken(ApexParser.SEMI, 0); + } + public block(): BlockContext | null { + return this.getRuleContext(0, BlockContext); + } + public override get ruleIndex(): number { + return ApexParser.RULE_setter; + } + public override enterRule(listener: ApexParserListener): void { + if(listener.enterSetter) { + listener.enterSetter(this); + } + } + public override exitRule(listener: ApexParserListener): void { + if(listener.exitSetter) { + listener.exitSetter(this); + } + } + public override accept(visitor: ApexParserVisitor): Result | null { + if (visitor.visitSetter) { + return visitor.visitSetter(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class CatchClauseContext extends antlr.ParserRuleContext { + public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { + super(parent, invokingState); + } + public CATCH(): antlr.TerminalNode { + return this.getToken(ApexParser.CATCH, 0)!; + } + public LPAREN(): antlr.TerminalNode { + return this.getToken(ApexParser.LPAREN, 0)!; + } + public qualifiedName(): QualifiedNameContext { + return this.getRuleContext(0, QualifiedNameContext)!; + } + public id(): IdContext { + return this.getRuleContext(0, IdContext)!; + } + public RPAREN(): antlr.TerminalNode { + return this.getToken(ApexParser.RPAREN, 0)!; + } + public block(): BlockContext { + return this.getRuleContext(0, BlockContext)!; + } + public modifier(): ModifierContext[]; + public modifier(i: number): ModifierContext | null; + public modifier(i?: number): ModifierContext[] | ModifierContext | null { + if (i === undefined) { + return this.getRuleContexts(ModifierContext); + } + + return this.getRuleContext(i, ModifierContext); + } + public override get ruleIndex(): number { + return ApexParser.RULE_catchClause; + } + public override enterRule(listener: ApexParserListener): void { + if(listener.enterCatchClause) { + listener.enterCatchClause(this); + } + } + public override exitRule(listener: ApexParserListener): void { + if(listener.exitCatchClause) { + listener.exitCatchClause(this); + } + } + public override accept(visitor: ApexParserVisitor): Result | null { + if (visitor.visitCatchClause) { + return visitor.visitCatchClause(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class FinallyBlockContext extends antlr.ParserRuleContext { + public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { + super(parent, invokingState); + } + public FINALLY(): antlr.TerminalNode { + return this.getToken(ApexParser.FINALLY, 0)!; + } + public block(): BlockContext { + return this.getRuleContext(0, BlockContext)!; + } + public override get ruleIndex(): number { + return ApexParser.RULE_finallyBlock; + } + public override enterRule(listener: ApexParserListener): void { + if(listener.enterFinallyBlock) { + listener.enterFinallyBlock(this); + } + } + public override exitRule(listener: ApexParserListener): void { + if(listener.exitFinallyBlock) { + listener.exitFinallyBlock(this); + } + } + public override accept(visitor: ApexParserVisitor): Result | null { + if (visitor.visitFinallyBlock) { + return visitor.visitFinallyBlock(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class ForControlContext extends antlr.ParserRuleContext { + public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { + super(parent, invokingState); + } + public enhancedForControl(): EnhancedForControlContext | null { + return this.getRuleContext(0, EnhancedForControlContext); + } + public SEMI(): antlr.TerminalNode[]; + public SEMI(i: number): antlr.TerminalNode | null; + public SEMI(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { + if (i === undefined) { + return this.getTokens(ApexParser.SEMI); + } else { + return this.getToken(ApexParser.SEMI, i); + } + } + public forInit(): ForInitContext | null { + return this.getRuleContext(0, ForInitContext); + } + public expression(): ExpressionContext | null { + return this.getRuleContext(0, ExpressionContext); + } + public forUpdate(): ForUpdateContext | null { + return this.getRuleContext(0, ForUpdateContext); + } + public override get ruleIndex(): number { + return ApexParser.RULE_forControl; + } + public override enterRule(listener: ApexParserListener): void { + if(listener.enterForControl) { + listener.enterForControl(this); + } + } + public override exitRule(listener: ApexParserListener): void { + if(listener.exitForControl) { + listener.exitForControl(this); + } + } + public override accept(visitor: ApexParserVisitor): Result | null { + if (visitor.visitForControl) { + return visitor.visitForControl(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class ForInitContext extends antlr.ParserRuleContext { + public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { + super(parent, invokingState); + } + public localVariableDeclaration(): LocalVariableDeclarationContext | null { + return this.getRuleContext(0, LocalVariableDeclarationContext); + } + public expressionList(): ExpressionListContext | null { + return this.getRuleContext(0, ExpressionListContext); + } + public override get ruleIndex(): number { + return ApexParser.RULE_forInit; + } + public override enterRule(listener: ApexParserListener): void { + if(listener.enterForInit) { + listener.enterForInit(this); + } + } + public override exitRule(listener: ApexParserListener): void { + if(listener.exitForInit) { + listener.exitForInit(this); + } + } + public override accept(visitor: ApexParserVisitor): Result | null { + if (visitor.visitForInit) { + return visitor.visitForInit(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class EnhancedForControlContext extends antlr.ParserRuleContext { + public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { + super(parent, invokingState); + } + public typeRef(): TypeRefContext { + return this.getRuleContext(0, TypeRefContext)!; + } + public id(): IdContext { + return this.getRuleContext(0, IdContext)!; + } + public COLON(): antlr.TerminalNode { + return this.getToken(ApexParser.COLON, 0)!; + } + public expression(): ExpressionContext { + return this.getRuleContext(0, ExpressionContext)!; + } + public override get ruleIndex(): number { + return ApexParser.RULE_enhancedForControl; + } + public override enterRule(listener: ApexParserListener): void { + if(listener.enterEnhancedForControl) { + listener.enterEnhancedForControl(this); + } + } + public override exitRule(listener: ApexParserListener): void { + if(listener.exitEnhancedForControl) { + listener.exitEnhancedForControl(this); + } + } + public override accept(visitor: ApexParserVisitor): Result | null { + if (visitor.visitEnhancedForControl) { + return visitor.visitEnhancedForControl(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class ForUpdateContext extends antlr.ParserRuleContext { + public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { + super(parent, invokingState); + } + public expressionList(): ExpressionListContext { + return this.getRuleContext(0, ExpressionListContext)!; + } + public override get ruleIndex(): number { + return ApexParser.RULE_forUpdate; + } + public override enterRule(listener: ApexParserListener): void { + if(listener.enterForUpdate) { + listener.enterForUpdate(this); + } + } + public override exitRule(listener: ApexParserListener): void { + if(listener.exitForUpdate) { + listener.exitForUpdate(this); + } + } + public override accept(visitor: ApexParserVisitor): Result | null { + if (visitor.visitForUpdate) { + return visitor.visitForUpdate(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class ParExpressionContext extends antlr.ParserRuleContext { + public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { + super(parent, invokingState); + } + public LPAREN(): antlr.TerminalNode { + return this.getToken(ApexParser.LPAREN, 0)!; + } + public expression(): ExpressionContext { + return this.getRuleContext(0, ExpressionContext)!; + } + public RPAREN(): antlr.TerminalNode { + return this.getToken(ApexParser.RPAREN, 0)!; + } + public override get ruleIndex(): number { + return ApexParser.RULE_parExpression; + } + public override enterRule(listener: ApexParserListener): void { + if(listener.enterParExpression) { + listener.enterParExpression(this); + } + } + public override exitRule(listener: ApexParserListener): void { + if(listener.exitParExpression) { + listener.exitParExpression(this); + } + } + public override accept(visitor: ApexParserVisitor): Result | null { + if (visitor.visitParExpression) { + return visitor.visitParExpression(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class ExpressionListContext extends antlr.ParserRuleContext { + public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { + super(parent, invokingState); + } + public expression(): ExpressionContext[]; + public expression(i: number): ExpressionContext | null; + public expression(i?: number): ExpressionContext[] | ExpressionContext | null { + if (i === undefined) { + return this.getRuleContexts(ExpressionContext); + } + + return this.getRuleContext(i, ExpressionContext); + } + public COMMA(): antlr.TerminalNode[]; + public COMMA(i: number): antlr.TerminalNode | null; + public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { + if (i === undefined) { + return this.getTokens(ApexParser.COMMA); + } else { + return this.getToken(ApexParser.COMMA, i); + } + } + public override get ruleIndex(): number { + return ApexParser.RULE_expressionList; + } + public override enterRule(listener: ApexParserListener): void { + if(listener.enterExpressionList) { + listener.enterExpressionList(this); + } + } + public override exitRule(listener: ApexParserListener): void { + if(listener.exitExpressionList) { + listener.exitExpressionList(this); + } + } + public override accept(visitor: ApexParserVisitor): Result | null { + if (visitor.visitExpressionList) { + return visitor.visitExpressionList(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class ExpressionContext extends antlr.ParserRuleContext { + public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { + super(parent, invokingState); + } + public override get ruleIndex(): number { + return ApexParser.RULE_expression; + } + public override copyFrom(ctx: ExpressionContext): void { + super.copyFrom(ctx); + } +} +export class PrimaryExpressionContext extends ExpressionContext { + public constructor(ctx: ExpressionContext) { + super(ctx.parent, ctx.invokingState); + super.copyFrom(ctx); + } + public primary(): PrimaryContext { + return this.getRuleContext(0, PrimaryContext)!; + } + public override enterRule(listener: ApexParserListener): void { + if(listener.enterPrimaryExpression) { + listener.enterPrimaryExpression(this); + } + } + public override exitRule(listener: ApexParserListener): void { + if(listener.exitPrimaryExpression) { + listener.exitPrimaryExpression(this); + } + } + public override accept(visitor: ApexParserVisitor): Result | null { + if (visitor.visitPrimaryExpression) { + return visitor.visitPrimaryExpression(this); + } else { + return visitor.visitChildren(this); + } + } +} +export class Arth1ExpressionContext extends ExpressionContext { + public constructor(ctx: ExpressionContext) { + super(ctx.parent, ctx.invokingState); + super.copyFrom(ctx); + } + public expression(): ExpressionContext[]; + public expression(i: number): ExpressionContext | null; + public expression(i?: number): ExpressionContext[] | ExpressionContext | null { + if (i === undefined) { + return this.getRuleContexts(ExpressionContext); + } + + return this.getRuleContext(i, ExpressionContext); + } + public MUL(): antlr.TerminalNode | null { + return this.getToken(ApexParser.MUL, 0); + } + public DIV(): antlr.TerminalNode | null { + return this.getToken(ApexParser.DIV, 0); + } + public override enterRule(listener: ApexParserListener): void { + if(listener.enterArth1Expression) { + listener.enterArth1Expression(this); + } + } + public override exitRule(listener: ApexParserListener): void { + if(listener.exitArth1Expression) { + listener.exitArth1Expression(this); + } + } + public override accept(visitor: ApexParserVisitor): Result | null { + if (visitor.visitArth1Expression) { + return visitor.visitArth1Expression(this); + } else { + return visitor.visitChildren(this); + } + } +} +export class DotExpressionContext extends ExpressionContext { + public constructor(ctx: ExpressionContext) { + super(ctx.parent, ctx.invokingState); + super.copyFrom(ctx); + } + public expression(): ExpressionContext { + return this.getRuleContext(0, ExpressionContext)!; + } + public DOT(): antlr.TerminalNode | null { + return this.getToken(ApexParser.DOT, 0); + } + public QUESTIONDOT(): antlr.TerminalNode | null { + return this.getToken(ApexParser.QUESTIONDOT, 0); + } + public dotMethodCall(): DotMethodCallContext | null { + return this.getRuleContext(0, DotMethodCallContext); + } + public anyId(): AnyIdContext | null { + return this.getRuleContext(0, AnyIdContext); + } + public override enterRule(listener: ApexParserListener): void { + if(listener.enterDotExpression) { + listener.enterDotExpression(this); + } + } + public override exitRule(listener: ApexParserListener): void { + if(listener.exitDotExpression) { + listener.exitDotExpression(this); + } + } + public override accept(visitor: ApexParserVisitor): Result | null { + if (visitor.visitDotExpression) { + return visitor.visitDotExpression(this); + } else { + return visitor.visitChildren(this); + } + } +} +export class BitOrExpressionContext extends ExpressionContext { + public constructor(ctx: ExpressionContext) { + super(ctx.parent, ctx.invokingState); + super.copyFrom(ctx); + } + public expression(): ExpressionContext[]; + public expression(i: number): ExpressionContext | null; + public expression(i?: number): ExpressionContext[] | ExpressionContext | null { + if (i === undefined) { + return this.getRuleContexts(ExpressionContext); + } + + return this.getRuleContext(i, ExpressionContext); + } + public BITOR(): antlr.TerminalNode { + return this.getToken(ApexParser.BITOR, 0)!; + } + public override enterRule(listener: ApexParserListener): void { + if(listener.enterBitOrExpression) { + listener.enterBitOrExpression(this); + } + } + public override exitRule(listener: ApexParserListener): void { + if(listener.exitBitOrExpression) { + listener.exitBitOrExpression(this); + } + } + public override accept(visitor: ApexParserVisitor): Result | null { + if (visitor.visitBitOrExpression) { + return visitor.visitBitOrExpression(this); + } else { + return visitor.visitChildren(this); + } + } +} +export class ArrayExpressionContext extends ExpressionContext { + public constructor(ctx: ExpressionContext) { + super(ctx.parent, ctx.invokingState); + super.copyFrom(ctx); + } + public expression(): ExpressionContext[]; + public expression(i: number): ExpressionContext | null; + public expression(i?: number): ExpressionContext[] | ExpressionContext | null { + if (i === undefined) { + return this.getRuleContexts(ExpressionContext); + } + + return this.getRuleContext(i, ExpressionContext); + } + public LBRACK(): antlr.TerminalNode { + return this.getToken(ApexParser.LBRACK, 0)!; + } + public RBRACK(): antlr.TerminalNode { + return this.getToken(ApexParser.RBRACK, 0)!; + } + public override enterRule(listener: ApexParserListener): void { + if(listener.enterArrayExpression) { + listener.enterArrayExpression(this); + } + } + public override exitRule(listener: ApexParserListener): void { + if(listener.exitArrayExpression) { + listener.exitArrayExpression(this); + } + } + public override accept(visitor: ApexParserVisitor): Result | null { + if (visitor.visitArrayExpression) { + return visitor.visitArrayExpression(this); + } else { + return visitor.visitChildren(this); + } + } +} +export class NewExpressionContext extends ExpressionContext { + public constructor(ctx: ExpressionContext) { + super(ctx.parent, ctx.invokingState); + super.copyFrom(ctx); + } + public NEW(): antlr.TerminalNode { + return this.getToken(ApexParser.NEW, 0)!; + } + public creator(): CreatorContext { + return this.getRuleContext(0, CreatorContext)!; + } + public override enterRule(listener: ApexParserListener): void { + if(listener.enterNewExpression) { + listener.enterNewExpression(this); + } + } + public override exitRule(listener: ApexParserListener): void { + if(listener.exitNewExpression) { + listener.exitNewExpression(this); + } + } + public override accept(visitor: ApexParserVisitor): Result | null { + if (visitor.visitNewExpression) { + return visitor.visitNewExpression(this); + } else { + return visitor.visitChildren(this); + } + } +} +export class AssignExpressionContext extends ExpressionContext { + public constructor(ctx: ExpressionContext) { + super(ctx.parent, ctx.invokingState); + super.copyFrom(ctx); + } + public expression(): ExpressionContext[]; + public expression(i: number): ExpressionContext | null; + public expression(i?: number): ExpressionContext[] | ExpressionContext | null { + if (i === undefined) { + return this.getRuleContexts(ExpressionContext); + } + + return this.getRuleContext(i, ExpressionContext); + } + public ASSIGN(): antlr.TerminalNode | null { + return this.getToken(ApexParser.ASSIGN, 0); + } + public ADD_ASSIGN(): antlr.TerminalNode | null { + return this.getToken(ApexParser.ADD_ASSIGN, 0); + } + public SUB_ASSIGN(): antlr.TerminalNode | null { + return this.getToken(ApexParser.SUB_ASSIGN, 0); + } + public MUL_ASSIGN(): antlr.TerminalNode | null { + return this.getToken(ApexParser.MUL_ASSIGN, 0); + } + public DIV_ASSIGN(): antlr.TerminalNode | null { + return this.getToken(ApexParser.DIV_ASSIGN, 0); + } + public AND_ASSIGN(): antlr.TerminalNode | null { + return this.getToken(ApexParser.AND_ASSIGN, 0); + } + public OR_ASSIGN(): antlr.TerminalNode | null { + return this.getToken(ApexParser.OR_ASSIGN, 0); + } + public XOR_ASSIGN(): antlr.TerminalNode | null { + return this.getToken(ApexParser.XOR_ASSIGN, 0); + } + public RSHIFT_ASSIGN(): antlr.TerminalNode | null { + return this.getToken(ApexParser.RSHIFT_ASSIGN, 0); + } + public URSHIFT_ASSIGN(): antlr.TerminalNode | null { + return this.getToken(ApexParser.URSHIFT_ASSIGN, 0); + } + public LSHIFT_ASSIGN(): antlr.TerminalNode | null { + return this.getToken(ApexParser.LSHIFT_ASSIGN, 0); + } + public override enterRule(listener: ApexParserListener): void { + if(listener.enterAssignExpression) { + listener.enterAssignExpression(this); + } + } + public override exitRule(listener: ApexParserListener): void { + if(listener.exitAssignExpression) { + listener.exitAssignExpression(this); + } + } + public override accept(visitor: ApexParserVisitor): Result | null { + if (visitor.visitAssignExpression) { + return visitor.visitAssignExpression(this); + } else { + return visitor.visitChildren(this); + } + } +} +export class MethodCallExpressionContext extends ExpressionContext { + public constructor(ctx: ExpressionContext) { + super(ctx.parent, ctx.invokingState); + super.copyFrom(ctx); + } + public methodCall(): MethodCallContext { + return this.getRuleContext(0, MethodCallContext)!; + } + public override enterRule(listener: ApexParserListener): void { + if(listener.enterMethodCallExpression) { + listener.enterMethodCallExpression(this); + } + } + public override exitRule(listener: ApexParserListener): void { + if(listener.exitMethodCallExpression) { + listener.exitMethodCallExpression(this); + } + } + public override accept(visitor: ApexParserVisitor): Result | null { + if (visitor.visitMethodCallExpression) { + return visitor.visitMethodCallExpression(this); + } else { + return visitor.visitChildren(this); + } + } +} +export class BitNotExpressionContext extends ExpressionContext { + public constructor(ctx: ExpressionContext) { + super(ctx.parent, ctx.invokingState); + super.copyFrom(ctx); + } + public expression(): ExpressionContext[]; + public expression(i: number): ExpressionContext | null; + public expression(i?: number): ExpressionContext[] | ExpressionContext | null { + if (i === undefined) { + return this.getRuleContexts(ExpressionContext); + } + + return this.getRuleContext(i, ExpressionContext); + } + public CARET(): antlr.TerminalNode { + return this.getToken(ApexParser.CARET, 0)!; + } + public override enterRule(listener: ApexParserListener): void { + if(listener.enterBitNotExpression) { + listener.enterBitNotExpression(this); + } + } + public override exitRule(listener: ApexParserListener): void { + if(listener.exitBitNotExpression) { + listener.exitBitNotExpression(this); + } + } + public override accept(visitor: ApexParserVisitor): Result | null { + if (visitor.visitBitNotExpression) { + return visitor.visitBitNotExpression(this); + } else { + return visitor.visitChildren(this); + } + } +} +export class Arth2ExpressionContext extends ExpressionContext { + public constructor(ctx: ExpressionContext) { + super(ctx.parent, ctx.invokingState); + super.copyFrom(ctx); + } + public expression(): ExpressionContext[]; + public expression(i: number): ExpressionContext | null; + public expression(i?: number): ExpressionContext[] | ExpressionContext | null { + if (i === undefined) { + return this.getRuleContexts(ExpressionContext); + } + + return this.getRuleContext(i, ExpressionContext); + } + public ADD(): antlr.TerminalNode | null { + return this.getToken(ApexParser.ADD, 0); + } + public SUB(): antlr.TerminalNode | null { + return this.getToken(ApexParser.SUB, 0); + } + public override enterRule(listener: ApexParserListener): void { + if(listener.enterArth2Expression) { + listener.enterArth2Expression(this); + } + } + public override exitRule(listener: ApexParserListener): void { + if(listener.exitArth2Expression) { + listener.exitArth2Expression(this); + } + } + public override accept(visitor: ApexParserVisitor): Result | null { + if (visitor.visitArth2Expression) { + return visitor.visitArth2Expression(this); + } else { + return visitor.visitChildren(this); + } + } +} +export class LogAndExpressionContext extends ExpressionContext { + public constructor(ctx: ExpressionContext) { + super(ctx.parent, ctx.invokingState); + super.copyFrom(ctx); + } + public expression(): ExpressionContext[]; + public expression(i: number): ExpressionContext | null; + public expression(i?: number): ExpressionContext[] | ExpressionContext | null { + if (i === undefined) { + return this.getRuleContexts(ExpressionContext); + } + + return this.getRuleContext(i, ExpressionContext); + } + public AND(): antlr.TerminalNode { + return this.getToken(ApexParser.AND, 0)!; + } + public override enterRule(listener: ApexParserListener): void { + if(listener.enterLogAndExpression) { + listener.enterLogAndExpression(this); + } + } + public override exitRule(listener: ApexParserListener): void { + if(listener.exitLogAndExpression) { + listener.exitLogAndExpression(this); + } + } + public override accept(visitor: ApexParserVisitor): Result | null { + if (visitor.visitLogAndExpression) { + return visitor.visitLogAndExpression(this); + } else { + return visitor.visitChildren(this); + } + } +} +export class CoalescingExpressionContext extends ExpressionContext { + public constructor(ctx: ExpressionContext) { + super(ctx.parent, ctx.invokingState); + super.copyFrom(ctx); + } + public expression(): ExpressionContext[]; + public expression(i: number): ExpressionContext | null; + public expression(i?: number): ExpressionContext[] | ExpressionContext | null { + if (i === undefined) { + return this.getRuleContexts(ExpressionContext); + } + + return this.getRuleContext(i, ExpressionContext); + } + public DOUBLEQUESTION(): antlr.TerminalNode { + return this.getToken(ApexParser.DOUBLEQUESTION, 0)!; + } + public override enterRule(listener: ApexParserListener): void { + if(listener.enterCoalescingExpression) { + listener.enterCoalescingExpression(this); + } + } + public override exitRule(listener: ApexParserListener): void { + if(listener.exitCoalescingExpression) { + listener.exitCoalescingExpression(this); + } + } + public override accept(visitor: ApexParserVisitor): Result | null { + if (visitor.visitCoalescingExpression) { + return visitor.visitCoalescingExpression(this); + } else { + return visitor.visitChildren(this); + } + } +} +export class CastExpressionContext extends ExpressionContext { + public constructor(ctx: ExpressionContext) { + super(ctx.parent, ctx.invokingState); + super.copyFrom(ctx); + } + public LPAREN(): antlr.TerminalNode { + return this.getToken(ApexParser.LPAREN, 0)!; + } + public typeRef(): TypeRefContext { + return this.getRuleContext(0, TypeRefContext)!; + } + public RPAREN(): antlr.TerminalNode { + return this.getToken(ApexParser.RPAREN, 0)!; + } + public expression(): ExpressionContext { + return this.getRuleContext(0, ExpressionContext)!; + } + public override enterRule(listener: ApexParserListener): void { + if(listener.enterCastExpression) { + listener.enterCastExpression(this); + } + } + public override exitRule(listener: ApexParserListener): void { + if(listener.exitCastExpression) { + listener.exitCastExpression(this); + } + } + public override accept(visitor: ApexParserVisitor): Result | null { + if (visitor.visitCastExpression) { + return visitor.visitCastExpression(this); + } else { + return visitor.visitChildren(this); + } + } +} +export class BitAndExpressionContext extends ExpressionContext { + public constructor(ctx: ExpressionContext) { + super(ctx.parent, ctx.invokingState); + super.copyFrom(ctx); + } + public expression(): ExpressionContext[]; + public expression(i: number): ExpressionContext | null; + public expression(i?: number): ExpressionContext[] | ExpressionContext | null { + if (i === undefined) { + return this.getRuleContexts(ExpressionContext); + } + + return this.getRuleContext(i, ExpressionContext); + } + public BITAND(): antlr.TerminalNode { + return this.getToken(ApexParser.BITAND, 0)!; + } + public override enterRule(listener: ApexParserListener): void { + if(listener.enterBitAndExpression) { + listener.enterBitAndExpression(this); + } + } + public override exitRule(listener: ApexParserListener): void { + if(listener.exitBitAndExpression) { + listener.exitBitAndExpression(this); + } + } + public override accept(visitor: ApexParserVisitor): Result | null { + if (visitor.visitBitAndExpression) { + return visitor.visitBitAndExpression(this); + } else { + return visitor.visitChildren(this); + } + } +} +export class CmpExpressionContext extends ExpressionContext { + public constructor(ctx: ExpressionContext) { + super(ctx.parent, ctx.invokingState); + super.copyFrom(ctx); + } + public expression(): ExpressionContext[]; + public expression(i: number): ExpressionContext | null; + public expression(i?: number): ExpressionContext[] | ExpressionContext | null { + if (i === undefined) { + return this.getRuleContexts(ExpressionContext); + } + + return this.getRuleContext(i, ExpressionContext); + } + public GT(): antlr.TerminalNode | null { + return this.getToken(ApexParser.GT, 0); + } + public LT(): antlr.TerminalNode | null { + return this.getToken(ApexParser.LT, 0); + } + public ASSIGN(): antlr.TerminalNode | null { + return this.getToken(ApexParser.ASSIGN, 0); + } + public override enterRule(listener: ApexParserListener): void { + if(listener.enterCmpExpression) { + listener.enterCmpExpression(this); + } + } + public override exitRule(listener: ApexParserListener): void { + if(listener.exitCmpExpression) { + listener.exitCmpExpression(this); + } + } + public override accept(visitor: ApexParserVisitor): Result | null { + if (visitor.visitCmpExpression) { + return visitor.visitCmpExpression(this); + } else { + return visitor.visitChildren(this); + } + } +} +export class BitExpressionContext extends ExpressionContext { + public constructor(ctx: ExpressionContext) { + super(ctx.parent, ctx.invokingState); + super.copyFrom(ctx); + } + public expression(): ExpressionContext[]; + public expression(i: number): ExpressionContext | null; + public expression(i?: number): ExpressionContext[] | ExpressionContext | null { + if (i === undefined) { + return this.getRuleContexts(ExpressionContext); + } + + return this.getRuleContext(i, ExpressionContext); + } + public LT(): antlr.TerminalNode[]; + public LT(i: number): antlr.TerminalNode | null; + public LT(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { + if (i === undefined) { + return this.getTokens(ApexParser.LT); + } else { + return this.getToken(ApexParser.LT, i); + } + } + public GT(): antlr.TerminalNode[]; + public GT(i: number): antlr.TerminalNode | null; + public GT(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { + if (i === undefined) { + return this.getTokens(ApexParser.GT); + } else { + return this.getToken(ApexParser.GT, i); + } + } + public override enterRule(listener: ApexParserListener): void { + if(listener.enterBitExpression) { + listener.enterBitExpression(this); + } + } + public override exitRule(listener: ApexParserListener): void { + if(listener.exitBitExpression) { + listener.exitBitExpression(this); + } + } + public override accept(visitor: ApexParserVisitor): Result | null { + if (visitor.visitBitExpression) { + return visitor.visitBitExpression(this); + } else { + return visitor.visitChildren(this); + } + } +} +export class LogOrExpressionContext extends ExpressionContext { + public constructor(ctx: ExpressionContext) { + super(ctx.parent, ctx.invokingState); + super.copyFrom(ctx); + } + public expression(): ExpressionContext[]; + public expression(i: number): ExpressionContext | null; + public expression(i?: number): ExpressionContext[] | ExpressionContext | null { + if (i === undefined) { + return this.getRuleContexts(ExpressionContext); + } + + return this.getRuleContext(i, ExpressionContext); + } + public OR(): antlr.TerminalNode { + return this.getToken(ApexParser.OR, 0)!; + } + public override enterRule(listener: ApexParserListener): void { + if(listener.enterLogOrExpression) { + listener.enterLogOrExpression(this); + } + } + public override exitRule(listener: ApexParserListener): void { + if(listener.exitLogOrExpression) { + listener.exitLogOrExpression(this); + } + } + public override accept(visitor: ApexParserVisitor): Result | null { + if (visitor.visitLogOrExpression) { + return visitor.visitLogOrExpression(this); + } else { + return visitor.visitChildren(this); + } + } +} +export class CondExpressionContext extends ExpressionContext { + public constructor(ctx: ExpressionContext) { + super(ctx.parent, ctx.invokingState); + super.copyFrom(ctx); + } + public expression(): ExpressionContext[]; + public expression(i: number): ExpressionContext | null; + public expression(i?: number): ExpressionContext[] | ExpressionContext | null { + if (i === undefined) { + return this.getRuleContexts(ExpressionContext); + } + + return this.getRuleContext(i, ExpressionContext); + } + public QUESTION(): antlr.TerminalNode { + return this.getToken(ApexParser.QUESTION, 0)!; + } + public COLON(): antlr.TerminalNode { + return this.getToken(ApexParser.COLON, 0)!; + } + public override enterRule(listener: ApexParserListener): void { + if(listener.enterCondExpression) { + listener.enterCondExpression(this); + } + } + public override exitRule(listener: ApexParserListener): void { + if(listener.exitCondExpression) { + listener.exitCondExpression(this); + } + } + public override accept(visitor: ApexParserVisitor): Result | null { + if (visitor.visitCondExpression) { + return visitor.visitCondExpression(this); + } else { + return visitor.visitChildren(this); + } + } +} +export class EqualityExpressionContext extends ExpressionContext { + public constructor(ctx: ExpressionContext) { + super(ctx.parent, ctx.invokingState); + super.copyFrom(ctx); + } + public expression(): ExpressionContext[]; + public expression(i: number): ExpressionContext | null; + public expression(i?: number): ExpressionContext[] | ExpressionContext | null { + if (i === undefined) { + return this.getRuleContexts(ExpressionContext); + } + + return this.getRuleContext(i, ExpressionContext); + } + public TRIPLEEQUAL(): antlr.TerminalNode | null { + return this.getToken(ApexParser.TRIPLEEQUAL, 0); + } + public TRIPLENOTEQUAL(): antlr.TerminalNode | null { + return this.getToken(ApexParser.TRIPLENOTEQUAL, 0); + } + public EQUAL(): antlr.TerminalNode | null { + return this.getToken(ApexParser.EQUAL, 0); + } + public NOTEQUAL(): antlr.TerminalNode | null { + return this.getToken(ApexParser.NOTEQUAL, 0); + } + public LESSANDGREATER(): antlr.TerminalNode | null { + return this.getToken(ApexParser.LESSANDGREATER, 0); + } + public override enterRule(listener: ApexParserListener): void { + if(listener.enterEqualityExpression) { + listener.enterEqualityExpression(this); + } + } + public override exitRule(listener: ApexParserListener): void { + if(listener.exitEqualityExpression) { + listener.exitEqualityExpression(this); + } + } + public override accept(visitor: ApexParserVisitor): Result | null { + if (visitor.visitEqualityExpression) { + return visitor.visitEqualityExpression(this); + } else { + return visitor.visitChildren(this); + } + } +} +export class PostOpExpressionContext extends ExpressionContext { + public constructor(ctx: ExpressionContext) { + super(ctx.parent, ctx.invokingState); + super.copyFrom(ctx); + } + public expression(): ExpressionContext { + return this.getRuleContext(0, ExpressionContext)!; + } + public INC(): antlr.TerminalNode | null { + return this.getToken(ApexParser.INC, 0); + } + public DEC(): antlr.TerminalNode | null { + return this.getToken(ApexParser.DEC, 0); + } + public override enterRule(listener: ApexParserListener): void { + if(listener.enterPostOpExpression) { + listener.enterPostOpExpression(this); + } + } + public override exitRule(listener: ApexParserListener): void { + if(listener.exitPostOpExpression) { + listener.exitPostOpExpression(this); + } + } + public override accept(visitor: ApexParserVisitor): Result | null { + if (visitor.visitPostOpExpression) { + return visitor.visitPostOpExpression(this); + } else { + return visitor.visitChildren(this); + } + } +} +export class NegExpressionContext extends ExpressionContext { + public constructor(ctx: ExpressionContext) { + super(ctx.parent, ctx.invokingState); + super.copyFrom(ctx); + } + public expression(): ExpressionContext { + return this.getRuleContext(0, ExpressionContext)!; + } + public TILDE(): antlr.TerminalNode | null { + return this.getToken(ApexParser.TILDE, 0); + } + public BANG(): antlr.TerminalNode | null { + return this.getToken(ApexParser.BANG, 0); + } + public override enterRule(listener: ApexParserListener): void { + if(listener.enterNegExpression) { + listener.enterNegExpression(this); + } + } + public override exitRule(listener: ApexParserListener): void { + if(listener.exitNegExpression) { + listener.exitNegExpression(this); + } + } + public override accept(visitor: ApexParserVisitor): Result | null { + if (visitor.visitNegExpression) { + return visitor.visitNegExpression(this); + } else { + return visitor.visitChildren(this); + } + } +} +export class PreOpExpressionContext extends ExpressionContext { + public constructor(ctx: ExpressionContext) { + super(ctx.parent, ctx.invokingState); + super.copyFrom(ctx); + } + public expression(): ExpressionContext { + return this.getRuleContext(0, ExpressionContext)!; + } + public ADD(): antlr.TerminalNode | null { + return this.getToken(ApexParser.ADD, 0); + } + public SUB(): antlr.TerminalNode | null { + return this.getToken(ApexParser.SUB, 0); + } + public INC(): antlr.TerminalNode | null { + return this.getToken(ApexParser.INC, 0); + } + public DEC(): antlr.TerminalNode | null { + return this.getToken(ApexParser.DEC, 0); + } + public override enterRule(listener: ApexParserListener): void { + if(listener.enterPreOpExpression) { + listener.enterPreOpExpression(this); + } + } + public override exitRule(listener: ApexParserListener): void { + if(listener.exitPreOpExpression) { + listener.exitPreOpExpression(this); + } + } + public override accept(visitor: ApexParserVisitor): Result | null { + if (visitor.visitPreOpExpression) { + return visitor.visitPreOpExpression(this); + } else { + return visitor.visitChildren(this); + } + } +} +export class SubExpressionContext extends ExpressionContext { + public constructor(ctx: ExpressionContext) { + super(ctx.parent, ctx.invokingState); + super.copyFrom(ctx); + } + public LPAREN(): antlr.TerminalNode { + return this.getToken(ApexParser.LPAREN, 0)!; + } + public expression(): ExpressionContext { + return this.getRuleContext(0, ExpressionContext)!; + } + public RPAREN(): antlr.TerminalNode { + return this.getToken(ApexParser.RPAREN, 0)!; + } + public override enterRule(listener: ApexParserListener): void { + if(listener.enterSubExpression) { + listener.enterSubExpression(this); + } + } + public override exitRule(listener: ApexParserListener): void { + if(listener.exitSubExpression) { + listener.exitSubExpression(this); + } + } + public override accept(visitor: ApexParserVisitor): Result | null { + if (visitor.visitSubExpression) { + return visitor.visitSubExpression(this); + } else { + return visitor.visitChildren(this); + } + } +} +export class InstanceOfExpressionContext extends ExpressionContext { + public constructor(ctx: ExpressionContext) { + super(ctx.parent, ctx.invokingState); + super.copyFrom(ctx); + } + public expression(): ExpressionContext { + return this.getRuleContext(0, ExpressionContext)!; + } + public INSTANCEOF(): antlr.TerminalNode { + return this.getToken(ApexParser.INSTANCEOF, 0)!; + } + public typeRef(): TypeRefContext { + return this.getRuleContext(0, TypeRefContext)!; + } + public override enterRule(listener: ApexParserListener): void { + if(listener.enterInstanceOfExpression) { + listener.enterInstanceOfExpression(this); + } + } + public override exitRule(listener: ApexParserListener): void { + if(listener.exitInstanceOfExpression) { + listener.exitInstanceOfExpression(this); + } + } + public override accept(visitor: ApexParserVisitor): Result | null { + if (visitor.visitInstanceOfExpression) { + return visitor.visitInstanceOfExpression(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class PrimaryContext extends antlr.ParserRuleContext { + public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { + super(parent, invokingState); + } + public override get ruleIndex(): number { + return ApexParser.RULE_primary; + } + public override copyFrom(ctx: PrimaryContext): void { + super.copyFrom(ctx); + } +} +export class ThisPrimaryContext extends PrimaryContext { + public constructor(ctx: PrimaryContext) { + super(ctx.parent, ctx.invokingState); + super.copyFrom(ctx); + } + public THIS(): antlr.TerminalNode { + return this.getToken(ApexParser.THIS, 0)!; + } + public override enterRule(listener: ApexParserListener): void { + if(listener.enterThisPrimary) { + listener.enterThisPrimary(this); + } + } + public override exitRule(listener: ApexParserListener): void { + if(listener.exitThisPrimary) { + listener.exitThisPrimary(this); + } + } + public override accept(visitor: ApexParserVisitor): Result | null { + if (visitor.visitThisPrimary) { + return visitor.visitThisPrimary(this); + } else { + return visitor.visitChildren(this); + } + } +} +export class VoidPrimaryContext extends PrimaryContext { + public constructor(ctx: PrimaryContext) { + super(ctx.parent, ctx.invokingState); + super.copyFrom(ctx); + } + public VOID(): antlr.TerminalNode { + return this.getToken(ApexParser.VOID, 0)!; + } + public DOT(): antlr.TerminalNode { + return this.getToken(ApexParser.DOT, 0)!; + } + public CLASS(): antlr.TerminalNode { + return this.getToken(ApexParser.CLASS, 0)!; + } + public override enterRule(listener: ApexParserListener): void { + if(listener.enterVoidPrimary) { + listener.enterVoidPrimary(this); + } + } + public override exitRule(listener: ApexParserListener): void { + if(listener.exitVoidPrimary) { + listener.exitVoidPrimary(this); + } + } + public override accept(visitor: ApexParserVisitor): Result | null { + if (visitor.visitVoidPrimary) { + return visitor.visitVoidPrimary(this); + } else { + return visitor.visitChildren(this); + } + } +} +export class SoqlPrimaryContext extends PrimaryContext { + public constructor(ctx: PrimaryContext) { + super(ctx.parent, ctx.invokingState); + super.copyFrom(ctx); + } + public soqlLiteral(): SoqlLiteralContext { + return this.getRuleContext(0, SoqlLiteralContext)!; + } + public override enterRule(listener: ApexParserListener): void { + if(listener.enterSoqlPrimary) { + listener.enterSoqlPrimary(this); + } + } + public override exitRule(listener: ApexParserListener): void { + if(listener.exitSoqlPrimary) { + listener.exitSoqlPrimary(this); + } + } + public override accept(visitor: ApexParserVisitor): Result | null { + if (visitor.visitSoqlPrimary) { + return visitor.visitSoqlPrimary(this); + } else { + return visitor.visitChildren(this); + } + } +} +export class SuperPrimaryContext extends PrimaryContext { + public constructor(ctx: PrimaryContext) { + super(ctx.parent, ctx.invokingState); + super.copyFrom(ctx); + } + public SUPER(): antlr.TerminalNode { + return this.getToken(ApexParser.SUPER, 0)!; + } + public override enterRule(listener: ApexParserListener): void { + if(listener.enterSuperPrimary) { + listener.enterSuperPrimary(this); + } + } + public override exitRule(listener: ApexParserListener): void { + if(listener.exitSuperPrimary) { + listener.exitSuperPrimary(this); + } + } + public override accept(visitor: ApexParserVisitor): Result | null { + if (visitor.visitSuperPrimary) { + return visitor.visitSuperPrimary(this); + } else { + return visitor.visitChildren(this); + } + } +} +export class TypeRefPrimaryContext extends PrimaryContext { + public constructor(ctx: PrimaryContext) { + super(ctx.parent, ctx.invokingState); + super.copyFrom(ctx); + } + public typeRef(): TypeRefContext { + return this.getRuleContext(0, TypeRefContext)!; + } + public DOT(): antlr.TerminalNode { + return this.getToken(ApexParser.DOT, 0)!; + } + public CLASS(): antlr.TerminalNode { + return this.getToken(ApexParser.CLASS, 0)!; + } + public override enterRule(listener: ApexParserListener): void { + if(listener.enterTypeRefPrimary) { + listener.enterTypeRefPrimary(this); + } + } + public override exitRule(listener: ApexParserListener): void { + if(listener.exitTypeRefPrimary) { + listener.exitTypeRefPrimary(this); + } + } + public override accept(visitor: ApexParserVisitor): Result | null { + if (visitor.visitTypeRefPrimary) { + return visitor.visitTypeRefPrimary(this); + } else { + return visitor.visitChildren(this); + } + } +} +export class IdPrimaryContext extends PrimaryContext { + public constructor(ctx: PrimaryContext) { + super(ctx.parent, ctx.invokingState); + super.copyFrom(ctx); + } + public id(): IdContext { + return this.getRuleContext(0, IdContext)!; + } + public override enterRule(listener: ApexParserListener): void { + if(listener.enterIdPrimary) { + listener.enterIdPrimary(this); + } + } + public override exitRule(listener: ApexParserListener): void { + if(listener.exitIdPrimary) { + listener.exitIdPrimary(this); + } + } + public override accept(visitor: ApexParserVisitor): Result | null { + if (visitor.visitIdPrimary) { + return visitor.visitIdPrimary(this); + } else { + return visitor.visitChildren(this); + } + } +} +export class SoslPrimaryContext extends PrimaryContext { + public constructor(ctx: PrimaryContext) { + super(ctx.parent, ctx.invokingState); + super.copyFrom(ctx); + } + public soslLiteral(): SoslLiteralContext { + return this.getRuleContext(0, SoslLiteralContext)!; + } + public override enterRule(listener: ApexParserListener): void { + if(listener.enterSoslPrimary) { + listener.enterSoslPrimary(this); + } + } + public override exitRule(listener: ApexParserListener): void { + if(listener.exitSoslPrimary) { + listener.exitSoslPrimary(this); + } + } + public override accept(visitor: ApexParserVisitor): Result | null { + if (visitor.visitSoslPrimary) { + return visitor.visitSoslPrimary(this); + } else { + return visitor.visitChildren(this); + } + } +} +export class LiteralPrimaryContext extends PrimaryContext { + public constructor(ctx: PrimaryContext) { + super(ctx.parent, ctx.invokingState); + super.copyFrom(ctx); + } + public literal(): LiteralContext { + return this.getRuleContext(0, LiteralContext)!; + } + public override enterRule(listener: ApexParserListener): void { + if(listener.enterLiteralPrimary) { + listener.enterLiteralPrimary(this); + } + } + public override exitRule(listener: ApexParserListener): void { + if(listener.exitLiteralPrimary) { + listener.exitLiteralPrimary(this); + } + } + public override accept(visitor: ApexParserVisitor): Result | null { + if (visitor.visitLiteralPrimary) { + return visitor.visitLiteralPrimary(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class MethodCallContext extends antlr.ParserRuleContext { + public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { + super(parent, invokingState); + } + public id(): IdContext | null { + return this.getRuleContext(0, IdContext); + } + public LPAREN(): antlr.TerminalNode { + return this.getToken(ApexParser.LPAREN, 0)!; + } + public RPAREN(): antlr.TerminalNode { + return this.getToken(ApexParser.RPAREN, 0)!; + } + public expressionList(): ExpressionListContext | null { + return this.getRuleContext(0, ExpressionListContext); + } + public THIS(): antlr.TerminalNode | null { + return this.getToken(ApexParser.THIS, 0); + } + public SUPER(): antlr.TerminalNode | null { + return this.getToken(ApexParser.SUPER, 0); + } + public override get ruleIndex(): number { + return ApexParser.RULE_methodCall; + } + public override enterRule(listener: ApexParserListener): void { + if(listener.enterMethodCall) { + listener.enterMethodCall(this); + } + } + public override exitRule(listener: ApexParserListener): void { + if(listener.exitMethodCall) { + listener.exitMethodCall(this); + } + } + public override accept(visitor: ApexParserVisitor): Result | null { + if (visitor.visitMethodCall) { + return visitor.visitMethodCall(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class DotMethodCallContext extends antlr.ParserRuleContext { + public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { + super(parent, invokingState); + } + public anyId(): AnyIdContext { + return this.getRuleContext(0, AnyIdContext)!; + } + public LPAREN(): antlr.TerminalNode { + return this.getToken(ApexParser.LPAREN, 0)!; + } + public RPAREN(): antlr.TerminalNode { + return this.getToken(ApexParser.RPAREN, 0)!; + } + public expressionList(): ExpressionListContext | null { + return this.getRuleContext(0, ExpressionListContext); + } + public override get ruleIndex(): number { + return ApexParser.RULE_dotMethodCall; + } + public override enterRule(listener: ApexParserListener): void { + if(listener.enterDotMethodCall) { + listener.enterDotMethodCall(this); + } + } + public override exitRule(listener: ApexParserListener): void { + if(listener.exitDotMethodCall) { + listener.exitDotMethodCall(this); + } + } + public override accept(visitor: ApexParserVisitor): Result | null { + if (visitor.visitDotMethodCall) { + return visitor.visitDotMethodCall(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class CreatorContext extends antlr.ParserRuleContext { + public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { + super(parent, invokingState); + } + public createdName(): CreatedNameContext { + return this.getRuleContext(0, CreatedNameContext)!; + } + public noRest(): NoRestContext | null { + return this.getRuleContext(0, NoRestContext); + } + public classCreatorRest(): ClassCreatorRestContext | null { + return this.getRuleContext(0, ClassCreatorRestContext); + } + public arrayCreatorRest(): ArrayCreatorRestContext | null { + return this.getRuleContext(0, ArrayCreatorRestContext); + } + public mapCreatorRest(): MapCreatorRestContext | null { + return this.getRuleContext(0, MapCreatorRestContext); + } + public setCreatorRest(): SetCreatorRestContext | null { + return this.getRuleContext(0, SetCreatorRestContext); + } + public override get ruleIndex(): number { + return ApexParser.RULE_creator; + } + public override enterRule(listener: ApexParserListener): void { + if(listener.enterCreator) { + listener.enterCreator(this); + } + } + public override exitRule(listener: ApexParserListener): void { + if(listener.exitCreator) { + listener.exitCreator(this); + } + } + public override accept(visitor: ApexParserVisitor): Result | null { + if (visitor.visitCreator) { + return visitor.visitCreator(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class CreatedNameContext extends antlr.ParserRuleContext { + public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { + super(parent, invokingState); + } + public idCreatedNamePair(): IdCreatedNamePairContext[]; + public idCreatedNamePair(i: number): IdCreatedNamePairContext | null; + public idCreatedNamePair(i?: number): IdCreatedNamePairContext[] | IdCreatedNamePairContext | null { + if (i === undefined) { + return this.getRuleContexts(IdCreatedNamePairContext); + } + + return this.getRuleContext(i, IdCreatedNamePairContext); + } + public DOT(): antlr.TerminalNode[]; + public DOT(i: number): antlr.TerminalNode | null; + public DOT(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { + if (i === undefined) { + return this.getTokens(ApexParser.DOT); + } else { + return this.getToken(ApexParser.DOT, i); + } + } + public override get ruleIndex(): number { + return ApexParser.RULE_createdName; + } + public override enterRule(listener: ApexParserListener): void { + if(listener.enterCreatedName) { + listener.enterCreatedName(this); + } + } + public override exitRule(listener: ApexParserListener): void { + if(listener.exitCreatedName) { + listener.exitCreatedName(this); + } + } + public override accept(visitor: ApexParserVisitor): Result | null { + if (visitor.visitCreatedName) { + return visitor.visitCreatedName(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class IdCreatedNamePairContext extends antlr.ParserRuleContext { + public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { + super(parent, invokingState); + } + public anyId(): AnyIdContext { + return this.getRuleContext(0, AnyIdContext)!; + } + public LT(): antlr.TerminalNode | null { + return this.getToken(ApexParser.LT, 0); + } + public typeList(): TypeListContext | null { + return this.getRuleContext(0, TypeListContext); + } + public GT(): antlr.TerminalNode | null { + return this.getToken(ApexParser.GT, 0); + } + public override get ruleIndex(): number { + return ApexParser.RULE_idCreatedNamePair; + } + public override enterRule(listener: ApexParserListener): void { + if(listener.enterIdCreatedNamePair) { + listener.enterIdCreatedNamePair(this); + } + } + public override exitRule(listener: ApexParserListener): void { + if(listener.exitIdCreatedNamePair) { + listener.exitIdCreatedNamePair(this); + } + } + public override accept(visitor: ApexParserVisitor): Result | null { + if (visitor.visitIdCreatedNamePair) { + return visitor.visitIdCreatedNamePair(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class NoRestContext extends antlr.ParserRuleContext { + public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { + super(parent, invokingState); + } + public LBRACE(): antlr.TerminalNode { + return this.getToken(ApexParser.LBRACE, 0)!; + } + public RBRACE(): antlr.TerminalNode { + return this.getToken(ApexParser.RBRACE, 0)!; + } + public override get ruleIndex(): number { + return ApexParser.RULE_noRest; + } + public override enterRule(listener: ApexParserListener): void { + if(listener.enterNoRest) { + listener.enterNoRest(this); + } + } + public override exitRule(listener: ApexParserListener): void { + if(listener.exitNoRest) { + listener.exitNoRest(this); + } + } + public override accept(visitor: ApexParserVisitor): Result | null { + if (visitor.visitNoRest) { + return visitor.visitNoRest(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class ClassCreatorRestContext extends antlr.ParserRuleContext { + public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { + super(parent, invokingState); + } + public arguments(): ArgumentsContext { + return this.getRuleContext(0, ArgumentsContext)!; + } + public override get ruleIndex(): number { + return ApexParser.RULE_classCreatorRest; + } + public override enterRule(listener: ApexParserListener): void { + if(listener.enterClassCreatorRest) { + listener.enterClassCreatorRest(this); + } + } + public override exitRule(listener: ApexParserListener): void { + if(listener.exitClassCreatorRest) { + listener.exitClassCreatorRest(this); + } + } + public override accept(visitor: ApexParserVisitor): Result | null { + if (visitor.visitClassCreatorRest) { + return visitor.visitClassCreatorRest(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class ArrayCreatorRestContext extends antlr.ParserRuleContext { + public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { + super(parent, invokingState); + } + public LBRACK(): antlr.TerminalNode { + return this.getToken(ApexParser.LBRACK, 0)!; + } + public expression(): ExpressionContext | null { + return this.getRuleContext(0, ExpressionContext); + } + public RBRACK(): antlr.TerminalNode { + return this.getToken(ApexParser.RBRACK, 0)!; + } + public arrayInitializer(): ArrayInitializerContext | null { + return this.getRuleContext(0, ArrayInitializerContext); + } + public override get ruleIndex(): number { + return ApexParser.RULE_arrayCreatorRest; + } + public override enterRule(listener: ApexParserListener): void { + if(listener.enterArrayCreatorRest) { + listener.enterArrayCreatorRest(this); + } + } + public override exitRule(listener: ApexParserListener): void { + if(listener.exitArrayCreatorRest) { + listener.exitArrayCreatorRest(this); + } + } + public override accept(visitor: ApexParserVisitor): Result | null { + if (visitor.visitArrayCreatorRest) { + return visitor.visitArrayCreatorRest(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class MapCreatorRestContext extends antlr.ParserRuleContext { + public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { + super(parent, invokingState); + } + public LBRACE(): antlr.TerminalNode { + return this.getToken(ApexParser.LBRACE, 0)!; + } + public mapCreatorRestPair(): MapCreatorRestPairContext[]; + public mapCreatorRestPair(i: number): MapCreatorRestPairContext | null; + public mapCreatorRestPair(i?: number): MapCreatorRestPairContext[] | MapCreatorRestPairContext | null { + if (i === undefined) { + return this.getRuleContexts(MapCreatorRestPairContext); + } + + return this.getRuleContext(i, MapCreatorRestPairContext); + } + public RBRACE(): antlr.TerminalNode { + return this.getToken(ApexParser.RBRACE, 0)!; + } + public COMMA(): antlr.TerminalNode[]; + public COMMA(i: number): antlr.TerminalNode | null; + public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { + if (i === undefined) { + return this.getTokens(ApexParser.COMMA); + } else { + return this.getToken(ApexParser.COMMA, i); + } + } + public override get ruleIndex(): number { + return ApexParser.RULE_mapCreatorRest; + } + public override enterRule(listener: ApexParserListener): void { + if(listener.enterMapCreatorRest) { + listener.enterMapCreatorRest(this); + } + } + public override exitRule(listener: ApexParserListener): void { + if(listener.exitMapCreatorRest) { + listener.exitMapCreatorRest(this); + } + } + public override accept(visitor: ApexParserVisitor): Result | null { + if (visitor.visitMapCreatorRest) { + return visitor.visitMapCreatorRest(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class MapCreatorRestPairContext extends antlr.ParserRuleContext { + public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { + super(parent, invokingState); + } + public expression(): ExpressionContext[]; + public expression(i: number): ExpressionContext | null; + public expression(i?: number): ExpressionContext[] | ExpressionContext | null { + if (i === undefined) { + return this.getRuleContexts(ExpressionContext); + } + + return this.getRuleContext(i, ExpressionContext); + } + public MAPTO(): antlr.TerminalNode { + return this.getToken(ApexParser.MAPTO, 0)!; + } + public override get ruleIndex(): number { + return ApexParser.RULE_mapCreatorRestPair; + } + public override enterRule(listener: ApexParserListener): void { + if(listener.enterMapCreatorRestPair) { + listener.enterMapCreatorRestPair(this); + } + } + public override exitRule(listener: ApexParserListener): void { + if(listener.exitMapCreatorRestPair) { + listener.exitMapCreatorRestPair(this); + } + } + public override accept(visitor: ApexParserVisitor): Result | null { + if (visitor.visitMapCreatorRestPair) { + return visitor.visitMapCreatorRestPair(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class SetCreatorRestContext extends antlr.ParserRuleContext { + public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { + super(parent, invokingState); + } + public LBRACE(): antlr.TerminalNode { + return this.getToken(ApexParser.LBRACE, 0)!; + } + public expression(): ExpressionContext[]; + public expression(i: number): ExpressionContext | null; + public expression(i?: number): ExpressionContext[] | ExpressionContext | null { + if (i === undefined) { + return this.getRuleContexts(ExpressionContext); + } + + return this.getRuleContext(i, ExpressionContext); + } + public RBRACE(): antlr.TerminalNode { + return this.getToken(ApexParser.RBRACE, 0)!; + } + public COMMA(): antlr.TerminalNode[]; + public COMMA(i: number): antlr.TerminalNode | null; + public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { + if (i === undefined) { + return this.getTokens(ApexParser.COMMA); + } else { + return this.getToken(ApexParser.COMMA, i); + } + } + public override get ruleIndex(): number { + return ApexParser.RULE_setCreatorRest; + } + public override enterRule(listener: ApexParserListener): void { + if(listener.enterSetCreatorRest) { + listener.enterSetCreatorRest(this); + } + } + public override exitRule(listener: ApexParserListener): void { + if(listener.exitSetCreatorRest) { + listener.exitSetCreatorRest(this); + } + } + public override accept(visitor: ApexParserVisitor): Result | null { + if (visitor.visitSetCreatorRest) { + return visitor.visitSetCreatorRest(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class ArgumentsContext extends antlr.ParserRuleContext { + public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { + super(parent, invokingState); + } + public LPAREN(): antlr.TerminalNode { + return this.getToken(ApexParser.LPAREN, 0)!; + } + public RPAREN(): antlr.TerminalNode { + return this.getToken(ApexParser.RPAREN, 0)!; + } + public expressionList(): ExpressionListContext | null { + return this.getRuleContext(0, ExpressionListContext); + } + public override get ruleIndex(): number { + return ApexParser.RULE_arguments; + } + public override enterRule(listener: ApexParserListener): void { + if(listener.enterArguments) { + listener.enterArguments(this); + } + } + public override exitRule(listener: ApexParserListener): void { + if(listener.exitArguments) { + listener.exitArguments(this); + } + } + public override accept(visitor: ApexParserVisitor): Result | null { + if (visitor.visitArguments) { + return visitor.visitArguments(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class SoqlLiteralContext extends antlr.ParserRuleContext { + public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { + super(parent, invokingState); + } + public LBRACK(): antlr.TerminalNode { + return this.getToken(ApexParser.LBRACK, 0)!; + } + public query(): QueryContext { + return this.getRuleContext(0, QueryContext)!; + } + public RBRACK(): antlr.TerminalNode { + return this.getToken(ApexParser.RBRACK, 0)!; + } + public override get ruleIndex(): number { + return ApexParser.RULE_soqlLiteral; + } + public override enterRule(listener: ApexParserListener): void { + if(listener.enterSoqlLiteral) { + listener.enterSoqlLiteral(this); + } + } + public override exitRule(listener: ApexParserListener): void { + if(listener.exitSoqlLiteral) { + listener.exitSoqlLiteral(this); + } + } + public override accept(visitor: ApexParserVisitor): Result | null { + if (visitor.visitSoqlLiteral) { + return visitor.visitSoqlLiteral(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class QueryContext extends antlr.ParserRuleContext { + public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { + super(parent, invokingState); + } + public SELECT(): antlr.TerminalNode { + return this.getToken(ApexParser.SELECT, 0)!; + } + public selectList(): SelectListContext { + return this.getRuleContext(0, SelectListContext)!; + } + public FROM(): antlr.TerminalNode { + return this.getToken(ApexParser.FROM, 0)!; + } + public fromNameList(): FromNameListContext { + return this.getRuleContext(0, FromNameListContext)!; + } + public forClauses(): ForClausesContext { + return this.getRuleContext(0, ForClausesContext)!; + } + public usingScope(): UsingScopeContext | null { + return this.getRuleContext(0, UsingScopeContext); + } + public whereClause(): WhereClauseContext | null { + return this.getRuleContext(0, WhereClauseContext); + } + public withClause(): WithClauseContext | null { + return this.getRuleContext(0, WithClauseContext); + } + public groupByClause(): GroupByClauseContext | null { + return this.getRuleContext(0, GroupByClauseContext); + } + public orderByClause(): OrderByClauseContext | null { + return this.getRuleContext(0, OrderByClauseContext); + } + public limitClause(): LimitClauseContext | null { + return this.getRuleContext(0, LimitClauseContext); + } + public offsetClause(): OffsetClauseContext | null { + return this.getRuleContext(0, OffsetClauseContext); + } + public allRowsClause(): AllRowsClauseContext | null { + return this.getRuleContext(0, AllRowsClauseContext); + } + public UPDATE(): antlr.TerminalNode | null { + return this.getToken(ApexParser.UPDATE, 0); + } + public updateList(): UpdateListContext | null { + return this.getRuleContext(0, UpdateListContext); + } + public override get ruleIndex(): number { + return ApexParser.RULE_query; + } + public override enterRule(listener: ApexParserListener): void { + if(listener.enterQuery) { + listener.enterQuery(this); + } + } + public override exitRule(listener: ApexParserListener): void { + if(listener.exitQuery) { + listener.exitQuery(this); + } + } + public override accept(visitor: ApexParserVisitor): Result | null { + if (visitor.visitQuery) { + return visitor.visitQuery(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class SubQueryContext extends antlr.ParserRuleContext { + public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { + super(parent, invokingState); + } + public SELECT(): antlr.TerminalNode { + return this.getToken(ApexParser.SELECT, 0)!; + } + public subFieldList(): SubFieldListContext { + return this.getRuleContext(0, SubFieldListContext)!; + } + public FROM(): antlr.TerminalNode { + return this.getToken(ApexParser.FROM, 0)!; + } + public fromNameList(): FromNameListContext { + return this.getRuleContext(0, FromNameListContext)!; + } + public forClauses(): ForClausesContext { + return this.getRuleContext(0, ForClausesContext)!; + } + public whereClause(): WhereClauseContext | null { + return this.getRuleContext(0, WhereClauseContext); + } + public orderByClause(): OrderByClauseContext | null { + return this.getRuleContext(0, OrderByClauseContext); + } + public limitClause(): LimitClauseContext | null { + return this.getRuleContext(0, LimitClauseContext); + } + public UPDATE(): antlr.TerminalNode | null { + return this.getToken(ApexParser.UPDATE, 0); + } + public updateList(): UpdateListContext | null { + return this.getRuleContext(0, UpdateListContext); + } + public override get ruleIndex(): number { + return ApexParser.RULE_subQuery; + } + public override enterRule(listener: ApexParserListener): void { + if(listener.enterSubQuery) { + listener.enterSubQuery(this); + } + } + public override exitRule(listener: ApexParserListener): void { + if(listener.exitSubQuery) { + listener.exitSubQuery(this); + } + } + public override accept(visitor: ApexParserVisitor): Result | null { + if (visitor.visitSubQuery) { + return visitor.visitSubQuery(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class SelectListContext extends antlr.ParserRuleContext { + public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { + super(parent, invokingState); + } + public selectEntry(): SelectEntryContext[]; + public selectEntry(i: number): SelectEntryContext | null; + public selectEntry(i?: number): SelectEntryContext[] | SelectEntryContext | null { + if (i === undefined) { + return this.getRuleContexts(SelectEntryContext); + } + + return this.getRuleContext(i, SelectEntryContext); + } + public COMMA(): antlr.TerminalNode[]; + public COMMA(i: number): antlr.TerminalNode | null; + public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { + if (i === undefined) { + return this.getTokens(ApexParser.COMMA); + } else { + return this.getToken(ApexParser.COMMA, i); + } + } + public override get ruleIndex(): number { + return ApexParser.RULE_selectList; + } + public override enterRule(listener: ApexParserListener): void { + if(listener.enterSelectList) { + listener.enterSelectList(this); + } + } + public override exitRule(listener: ApexParserListener): void { + if(listener.exitSelectList) { + listener.exitSelectList(this); + } + } + public override accept(visitor: ApexParserVisitor): Result | null { + if (visitor.visitSelectList) { + return visitor.visitSelectList(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class SelectEntryContext extends antlr.ParserRuleContext { + public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { + super(parent, invokingState); + } + public fieldName(): FieldNameContext | null { + return this.getRuleContext(0, FieldNameContext); + } + public soqlId(): SoqlIdContext | null { + return this.getRuleContext(0, SoqlIdContext); + } + public soqlFunction(): SoqlFunctionContext | null { + return this.getRuleContext(0, SoqlFunctionContext); + } + public LPAREN(): antlr.TerminalNode | null { + return this.getToken(ApexParser.LPAREN, 0); + } + public subQuery(): SubQueryContext | null { + return this.getRuleContext(0, SubQueryContext); + } + public RPAREN(): antlr.TerminalNode | null { + return this.getToken(ApexParser.RPAREN, 0); + } + public typeOf(): TypeOfContext | null { + return this.getRuleContext(0, TypeOfContext); + } + public override get ruleIndex(): number { + return ApexParser.RULE_selectEntry; + } + public override enterRule(listener: ApexParserListener): void { + if(listener.enterSelectEntry) { + listener.enterSelectEntry(this); + } + } + public override exitRule(listener: ApexParserListener): void { + if(listener.exitSelectEntry) { + listener.exitSelectEntry(this); + } + } + public override accept(visitor: ApexParserVisitor): Result | null { + if (visitor.visitSelectEntry) { + return visitor.visitSelectEntry(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class FieldNameContext extends antlr.ParserRuleContext { + public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { + super(parent, invokingState); + } + public soqlId(): SoqlIdContext[]; + public soqlId(i: number): SoqlIdContext | null; + public soqlId(i?: number): SoqlIdContext[] | SoqlIdContext | null { + if (i === undefined) { + return this.getRuleContexts(SoqlIdContext); + } + + return this.getRuleContext(i, SoqlIdContext); + } + public DOT(): antlr.TerminalNode[]; + public DOT(i: number): antlr.TerminalNode | null; + public DOT(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { + if (i === undefined) { + return this.getTokens(ApexParser.DOT); + } else { + return this.getToken(ApexParser.DOT, i); + } + } + public override get ruleIndex(): number { + return ApexParser.RULE_fieldName; + } + public override enterRule(listener: ApexParserListener): void { + if(listener.enterFieldName) { + listener.enterFieldName(this); + } + } + public override exitRule(listener: ApexParserListener): void { + if(listener.exitFieldName) { + listener.exitFieldName(this); + } + } + public override accept(visitor: ApexParserVisitor): Result | null { + if (visitor.visitFieldName) { + return visitor.visitFieldName(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class FromNameListContext extends antlr.ParserRuleContext { + public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { + super(parent, invokingState); + } + public fieldName(): FieldNameContext[]; + public fieldName(i: number): FieldNameContext | null; + public fieldName(i?: number): FieldNameContext[] | FieldNameContext | null { + if (i === undefined) { + return this.getRuleContexts(FieldNameContext); + } + + return this.getRuleContext(i, FieldNameContext); + } + public soqlId(): SoqlIdContext[]; + public soqlId(i: number): SoqlIdContext | null; + public soqlId(i?: number): SoqlIdContext[] | SoqlIdContext | null { + if (i === undefined) { + return this.getRuleContexts(SoqlIdContext); + } + + return this.getRuleContext(i, SoqlIdContext); + } + public COMMA(): antlr.TerminalNode[]; + public COMMA(i: number): antlr.TerminalNode | null; + public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { + if (i === undefined) { + return this.getTokens(ApexParser.COMMA); + } else { + return this.getToken(ApexParser.COMMA, i); + } + } + public override get ruleIndex(): number { + return ApexParser.RULE_fromNameList; + } + public override enterRule(listener: ApexParserListener): void { + if(listener.enterFromNameList) { + listener.enterFromNameList(this); + } + } + public override exitRule(listener: ApexParserListener): void { + if(listener.exitFromNameList) { + listener.exitFromNameList(this); + } + } + public override accept(visitor: ApexParserVisitor): Result | null { + if (visitor.visitFromNameList) { + return visitor.visitFromNameList(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class SubFieldListContext extends antlr.ParserRuleContext { + public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { + super(parent, invokingState); + } + public subFieldEntry(): SubFieldEntryContext[]; + public subFieldEntry(i: number): SubFieldEntryContext | null; + public subFieldEntry(i?: number): SubFieldEntryContext[] | SubFieldEntryContext | null { + if (i === undefined) { + return this.getRuleContexts(SubFieldEntryContext); + } + + return this.getRuleContext(i, SubFieldEntryContext); + } + public COMMA(): antlr.TerminalNode[]; + public COMMA(i: number): antlr.TerminalNode | null; + public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { + if (i === undefined) { + return this.getTokens(ApexParser.COMMA); + } else { + return this.getToken(ApexParser.COMMA, i); + } + } + public override get ruleIndex(): number { + return ApexParser.RULE_subFieldList; + } + public override enterRule(listener: ApexParserListener): void { + if(listener.enterSubFieldList) { + listener.enterSubFieldList(this); + } + } + public override exitRule(listener: ApexParserListener): void { + if(listener.exitSubFieldList) { + listener.exitSubFieldList(this); + } + } + public override accept(visitor: ApexParserVisitor): Result | null { + if (visitor.visitSubFieldList) { + return visitor.visitSubFieldList(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class SubFieldEntryContext extends antlr.ParserRuleContext { + public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { + super(parent, invokingState); + } + public fieldName(): FieldNameContext | null { + return this.getRuleContext(0, FieldNameContext); + } + public soqlId(): SoqlIdContext | null { + return this.getRuleContext(0, SoqlIdContext); + } + public soqlFunction(): SoqlFunctionContext | null { + return this.getRuleContext(0, SoqlFunctionContext); + } + public typeOf(): TypeOfContext | null { + return this.getRuleContext(0, TypeOfContext); + } + public override get ruleIndex(): number { + return ApexParser.RULE_subFieldEntry; + } + public override enterRule(listener: ApexParserListener): void { + if(listener.enterSubFieldEntry) { + listener.enterSubFieldEntry(this); + } + } + public override exitRule(listener: ApexParserListener): void { + if(listener.exitSubFieldEntry) { + listener.exitSubFieldEntry(this); + } + } + public override accept(visitor: ApexParserVisitor): Result | null { + if (visitor.visitSubFieldEntry) { + return visitor.visitSubFieldEntry(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class SoqlFieldsParameterContext extends antlr.ParserRuleContext { + public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { + super(parent, invokingState); + } + public ALL(): antlr.TerminalNode | null { + return this.getToken(ApexParser.ALL, 0); + } + public CUSTOM(): antlr.TerminalNode | null { + return this.getToken(ApexParser.CUSTOM, 0); + } + public STANDARD(): antlr.TerminalNode | null { + return this.getToken(ApexParser.STANDARD, 0); + } + public override get ruleIndex(): number { + return ApexParser.RULE_soqlFieldsParameter; + } + public override enterRule(listener: ApexParserListener): void { + if(listener.enterSoqlFieldsParameter) { + listener.enterSoqlFieldsParameter(this); + } + } + public override exitRule(listener: ApexParserListener): void { + if(listener.exitSoqlFieldsParameter) { + listener.exitSoqlFieldsParameter(this); + } + } + public override accept(visitor: ApexParserVisitor): Result | null { + if (visitor.visitSoqlFieldsParameter) { + return visitor.visitSoqlFieldsParameter(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class SoqlFunctionContext extends antlr.ParserRuleContext { + public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { + super(parent, invokingState); + } + public AVG(): antlr.TerminalNode | null { + return this.getToken(ApexParser.AVG, 0); + } + public LPAREN(): antlr.TerminalNode { + return this.getToken(ApexParser.LPAREN, 0)!; + } + public fieldName(): FieldNameContext | null { + return this.getRuleContext(0, FieldNameContext); + } + public RPAREN(): antlr.TerminalNode { + return this.getToken(ApexParser.RPAREN, 0)!; + } + public COUNT(): antlr.TerminalNode | null { + return this.getToken(ApexParser.COUNT, 0); + } + public COUNT_DISTINCT(): antlr.TerminalNode | null { + return this.getToken(ApexParser.COUNT_DISTINCT, 0); + } + public MIN(): antlr.TerminalNode | null { + return this.getToken(ApexParser.MIN, 0); + } + public MAX(): antlr.TerminalNode | null { + return this.getToken(ApexParser.MAX, 0); + } + public SUM(): antlr.TerminalNode | null { + return this.getToken(ApexParser.SUM, 0); + } + public TOLABEL(): antlr.TerminalNode | null { + return this.getToken(ApexParser.TOLABEL, 0); + } + public FORMAT(): antlr.TerminalNode | null { + return this.getToken(ApexParser.FORMAT, 0); + } + public CALENDAR_MONTH(): antlr.TerminalNode | null { + return this.getToken(ApexParser.CALENDAR_MONTH, 0); + } + public dateFieldName(): DateFieldNameContext | null { + return this.getRuleContext(0, DateFieldNameContext); + } + public CALENDAR_QUARTER(): antlr.TerminalNode | null { + return this.getToken(ApexParser.CALENDAR_QUARTER, 0); + } + public CALENDAR_YEAR(): antlr.TerminalNode | null { + return this.getToken(ApexParser.CALENDAR_YEAR, 0); + } + public DAY_IN_MONTH(): antlr.TerminalNode | null { + return this.getToken(ApexParser.DAY_IN_MONTH, 0); + } + public DAY_IN_WEEK(): antlr.TerminalNode | null { + return this.getToken(ApexParser.DAY_IN_WEEK, 0); + } + public DAY_IN_YEAR(): antlr.TerminalNode | null { + return this.getToken(ApexParser.DAY_IN_YEAR, 0); + } + public DAY_ONLY(): antlr.TerminalNode | null { + return this.getToken(ApexParser.DAY_ONLY, 0); + } + public FISCAL_MONTH(): antlr.TerminalNode | null { + return this.getToken(ApexParser.FISCAL_MONTH, 0); + } + public FISCAL_QUARTER(): antlr.TerminalNode | null { + return this.getToken(ApexParser.FISCAL_QUARTER, 0); + } + public FISCAL_YEAR(): antlr.TerminalNode | null { + return this.getToken(ApexParser.FISCAL_YEAR, 0); + } + public HOUR_IN_DAY(): antlr.TerminalNode | null { + return this.getToken(ApexParser.HOUR_IN_DAY, 0); + } + public WEEK_IN_MONTH(): antlr.TerminalNode | null { + return this.getToken(ApexParser.WEEK_IN_MONTH, 0); + } + public WEEK_IN_YEAR(): antlr.TerminalNode | null { + return this.getToken(ApexParser.WEEK_IN_YEAR, 0); + } + public FIELDS(): antlr.TerminalNode | null { + return this.getToken(ApexParser.FIELDS, 0); + } + public soqlFieldsParameter(): SoqlFieldsParameterContext | null { + return this.getRuleContext(0, SoqlFieldsParameterContext); + } + public DISTANCE(): antlr.TerminalNode | null { + return this.getToken(ApexParser.DISTANCE, 0); + } + public locationValue(): LocationValueContext[]; + public locationValue(i: number): LocationValueContext | null; + public locationValue(i?: number): LocationValueContext[] | LocationValueContext | null { + if (i === undefined) { + return this.getRuleContexts(LocationValueContext); + } + + return this.getRuleContext(i, LocationValueContext); + } + public COMMA(): antlr.TerminalNode[]; + public COMMA(i: number): antlr.TerminalNode | null; + public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { + if (i === undefined) { + return this.getTokens(ApexParser.COMMA); + } else { + return this.getToken(ApexParser.COMMA, i); + } + } + public StringLiteral(): antlr.TerminalNode | null { + return this.getToken(ApexParser.StringLiteral, 0); + } + public override get ruleIndex(): number { + return ApexParser.RULE_soqlFunction; + } + public override enterRule(listener: ApexParserListener): void { + if(listener.enterSoqlFunction) { + listener.enterSoqlFunction(this); + } + } + public override exitRule(listener: ApexParserListener): void { + if(listener.exitSoqlFunction) { + listener.exitSoqlFunction(this); + } + } + public override accept(visitor: ApexParserVisitor): Result | null { + if (visitor.visitSoqlFunction) { + return visitor.visitSoqlFunction(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class DateFieldNameContext extends antlr.ParserRuleContext { + public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { + super(parent, invokingState); + } + public CONVERT_TIMEZONE(): antlr.TerminalNode | null { + return this.getToken(ApexParser.CONVERT_TIMEZONE, 0); + } + public LPAREN(): antlr.TerminalNode | null { + return this.getToken(ApexParser.LPAREN, 0); + } + public fieldName(): FieldNameContext { + return this.getRuleContext(0, FieldNameContext)!; + } + public RPAREN(): antlr.TerminalNode | null { + return this.getToken(ApexParser.RPAREN, 0); + } + public override get ruleIndex(): number { + return ApexParser.RULE_dateFieldName; + } + public override enterRule(listener: ApexParserListener): void { + if(listener.enterDateFieldName) { + listener.enterDateFieldName(this); + } + } + public override exitRule(listener: ApexParserListener): void { + if(listener.exitDateFieldName) { + listener.exitDateFieldName(this); + } + } + public override accept(visitor: ApexParserVisitor): Result | null { + if (visitor.visitDateFieldName) { + return visitor.visitDateFieldName(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class LocationValueContext extends antlr.ParserRuleContext { + public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { + super(parent, invokingState); + } + public fieldName(): FieldNameContext | null { + return this.getRuleContext(0, FieldNameContext); + } + public boundExpression(): BoundExpressionContext | null { + return this.getRuleContext(0, BoundExpressionContext); + } + public GEOLOCATION(): antlr.TerminalNode | null { + return this.getToken(ApexParser.GEOLOCATION, 0); + } + public LPAREN(): antlr.TerminalNode | null { + return this.getToken(ApexParser.LPAREN, 0); + } + public coordinateValue(): CoordinateValueContext[]; + public coordinateValue(i: number): CoordinateValueContext | null; + public coordinateValue(i?: number): CoordinateValueContext[] | CoordinateValueContext | null { + if (i === undefined) { + return this.getRuleContexts(CoordinateValueContext); + } + + return this.getRuleContext(i, CoordinateValueContext); + } + public COMMA(): antlr.TerminalNode | null { + return this.getToken(ApexParser.COMMA, 0); + } + public RPAREN(): antlr.TerminalNode | null { + return this.getToken(ApexParser.RPAREN, 0); + } + public override get ruleIndex(): number { + return ApexParser.RULE_locationValue; + } + public override enterRule(listener: ApexParserListener): void { + if(listener.enterLocationValue) { + listener.enterLocationValue(this); + } + } + public override exitRule(listener: ApexParserListener): void { + if(listener.exitLocationValue) { + listener.exitLocationValue(this); + } + } + public override accept(visitor: ApexParserVisitor): Result | null { + if (visitor.visitLocationValue) { + return visitor.visitLocationValue(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class CoordinateValueContext extends antlr.ParserRuleContext { + public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { + super(parent, invokingState); + } + public signedNumber(): SignedNumberContext | null { + return this.getRuleContext(0, SignedNumberContext); + } + public boundExpression(): BoundExpressionContext | null { + return this.getRuleContext(0, BoundExpressionContext); + } + public override get ruleIndex(): number { + return ApexParser.RULE_coordinateValue; + } + public override enterRule(listener: ApexParserListener): void { + if(listener.enterCoordinateValue) { + listener.enterCoordinateValue(this); + } + } + public override exitRule(listener: ApexParserListener): void { + if(listener.exitCoordinateValue) { + listener.exitCoordinateValue(this); + } + } + public override accept(visitor: ApexParserVisitor): Result | null { + if (visitor.visitCoordinateValue) { + return visitor.visitCoordinateValue(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class TypeOfContext extends antlr.ParserRuleContext { + public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { + super(parent, invokingState); + } + public TYPEOF(): antlr.TerminalNode { + return this.getToken(ApexParser.TYPEOF, 0)!; + } + public fieldName(): FieldNameContext { + return this.getRuleContext(0, FieldNameContext)!; + } + public END(): antlr.TerminalNode { + return this.getToken(ApexParser.END, 0)!; + } + public whenClause(): WhenClauseContext[]; + public whenClause(i: number): WhenClauseContext | null; + public whenClause(i?: number): WhenClauseContext[] | WhenClauseContext | null { + if (i === undefined) { + return this.getRuleContexts(WhenClauseContext); + } + + return this.getRuleContext(i, WhenClauseContext); + } + public elseClause(): ElseClauseContext | null { + return this.getRuleContext(0, ElseClauseContext); + } + public override get ruleIndex(): number { + return ApexParser.RULE_typeOf; + } + public override enterRule(listener: ApexParserListener): void { + if(listener.enterTypeOf) { + listener.enterTypeOf(this); + } + } + public override exitRule(listener: ApexParserListener): void { + if(listener.exitTypeOf) { + listener.exitTypeOf(this); + } + } + public override accept(visitor: ApexParserVisitor): Result | null { + if (visitor.visitTypeOf) { + return visitor.visitTypeOf(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class WhenClauseContext extends antlr.ParserRuleContext { + public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { + super(parent, invokingState); + } + public WHEN(): antlr.TerminalNode { + return this.getToken(ApexParser.WHEN, 0)!; + } + public fieldName(): FieldNameContext { + return this.getRuleContext(0, FieldNameContext)!; + } + public THEN(): antlr.TerminalNode { + return this.getToken(ApexParser.THEN, 0)!; + } + public fieldNameList(): FieldNameListContext { + return this.getRuleContext(0, FieldNameListContext)!; + } + public override get ruleIndex(): number { + return ApexParser.RULE_whenClause; + } + public override enterRule(listener: ApexParserListener): void { + if(listener.enterWhenClause) { + listener.enterWhenClause(this); + } + } + public override exitRule(listener: ApexParserListener): void { + if(listener.exitWhenClause) { + listener.exitWhenClause(this); + } + } + public override accept(visitor: ApexParserVisitor): Result | null { + if (visitor.visitWhenClause) { + return visitor.visitWhenClause(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class ElseClauseContext extends antlr.ParserRuleContext { + public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { + super(parent, invokingState); + } + public ELSE(): antlr.TerminalNode { + return this.getToken(ApexParser.ELSE, 0)!; + } + public fieldNameList(): FieldNameListContext { + return this.getRuleContext(0, FieldNameListContext)!; + } + public override get ruleIndex(): number { + return ApexParser.RULE_elseClause; + } + public override enterRule(listener: ApexParserListener): void { + if(listener.enterElseClause) { + listener.enterElseClause(this); + } + } + public override exitRule(listener: ApexParserListener): void { + if(listener.exitElseClause) { + listener.exitElseClause(this); + } + } + public override accept(visitor: ApexParserVisitor): Result | null { + if (visitor.visitElseClause) { + return visitor.visitElseClause(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class FieldNameListContext extends antlr.ParserRuleContext { + public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { + super(parent, invokingState); + } + public fieldName(): FieldNameContext[]; + public fieldName(i: number): FieldNameContext | null; + public fieldName(i?: number): FieldNameContext[] | FieldNameContext | null { + if (i === undefined) { + return this.getRuleContexts(FieldNameContext); + } + + return this.getRuleContext(i, FieldNameContext); + } + public COMMA(): antlr.TerminalNode[]; + public COMMA(i: number): antlr.TerminalNode | null; + public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { + if (i === undefined) { + return this.getTokens(ApexParser.COMMA); + } else { + return this.getToken(ApexParser.COMMA, i); + } + } + public override get ruleIndex(): number { + return ApexParser.RULE_fieldNameList; + } + public override enterRule(listener: ApexParserListener): void { + if(listener.enterFieldNameList) { + listener.enterFieldNameList(this); + } + } + public override exitRule(listener: ApexParserListener): void { + if(listener.exitFieldNameList) { + listener.exitFieldNameList(this); + } + } + public override accept(visitor: ApexParserVisitor): Result | null { + if (visitor.visitFieldNameList) { + return visitor.visitFieldNameList(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class UsingScopeContext extends antlr.ParserRuleContext { + public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { + super(parent, invokingState); + } + public USING(): antlr.TerminalNode { + return this.getToken(ApexParser.USING, 0)!; + } + public SCOPE(): antlr.TerminalNode { + return this.getToken(ApexParser.SCOPE, 0)!; + } + public soqlId(): SoqlIdContext { + return this.getRuleContext(0, SoqlIdContext)!; + } + public override get ruleIndex(): number { + return ApexParser.RULE_usingScope; + } + public override enterRule(listener: ApexParserListener): void { + if(listener.enterUsingScope) { + listener.enterUsingScope(this); + } + } + public override exitRule(listener: ApexParserListener): void { + if(listener.exitUsingScope) { + listener.exitUsingScope(this); + } + } + public override accept(visitor: ApexParserVisitor): Result | null { + if (visitor.visitUsingScope) { + return visitor.visitUsingScope(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class WhereClauseContext extends antlr.ParserRuleContext { + public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { + super(parent, invokingState); + } + public WHERE(): antlr.TerminalNode { + return this.getToken(ApexParser.WHERE, 0)!; + } + public logicalExpression(): LogicalExpressionContext { + return this.getRuleContext(0, LogicalExpressionContext)!; + } + public override get ruleIndex(): number { + return ApexParser.RULE_whereClause; + } + public override enterRule(listener: ApexParserListener): void { + if(listener.enterWhereClause) { + listener.enterWhereClause(this); + } + } + public override exitRule(listener: ApexParserListener): void { + if(listener.exitWhereClause) { + listener.exitWhereClause(this); + } + } + public override accept(visitor: ApexParserVisitor): Result | null { + if (visitor.visitWhereClause) { + return visitor.visitWhereClause(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class LogicalExpressionContext extends antlr.ParserRuleContext { + public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { + super(parent, invokingState); + } + public conditionalExpression(): ConditionalExpressionContext[]; + public conditionalExpression(i: number): ConditionalExpressionContext | null; + public conditionalExpression(i?: number): ConditionalExpressionContext[] | ConditionalExpressionContext | null { + if (i === undefined) { + return this.getRuleContexts(ConditionalExpressionContext); + } + + return this.getRuleContext(i, ConditionalExpressionContext); + } + public SOQLAND(): antlr.TerminalNode[]; + public SOQLAND(i: number): antlr.TerminalNode | null; + public SOQLAND(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { + if (i === undefined) { + return this.getTokens(ApexParser.SOQLAND); + } else { + return this.getToken(ApexParser.SOQLAND, i); + } + } + public SOQLOR(): antlr.TerminalNode[]; + public SOQLOR(i: number): antlr.TerminalNode | null; + public SOQLOR(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { + if (i === undefined) { + return this.getTokens(ApexParser.SOQLOR); + } else { + return this.getToken(ApexParser.SOQLOR, i); + } + } + public NOT(): antlr.TerminalNode | null { + return this.getToken(ApexParser.NOT, 0); + } + public override get ruleIndex(): number { + return ApexParser.RULE_logicalExpression; + } + public override enterRule(listener: ApexParserListener): void { + if(listener.enterLogicalExpression) { + listener.enterLogicalExpression(this); + } + } + public override exitRule(listener: ApexParserListener): void { + if(listener.exitLogicalExpression) { + listener.exitLogicalExpression(this); + } + } + public override accept(visitor: ApexParserVisitor): Result | null { + if (visitor.visitLogicalExpression) { + return visitor.visitLogicalExpression(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class ConditionalExpressionContext extends antlr.ParserRuleContext { + public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { + super(parent, invokingState); + } + public LPAREN(): antlr.TerminalNode | null { + return this.getToken(ApexParser.LPAREN, 0); + } + public logicalExpression(): LogicalExpressionContext | null { + return this.getRuleContext(0, LogicalExpressionContext); + } + public RPAREN(): antlr.TerminalNode | null { + return this.getToken(ApexParser.RPAREN, 0); + } + public fieldExpression(): FieldExpressionContext | null { + return this.getRuleContext(0, FieldExpressionContext); + } + public override get ruleIndex(): number { + return ApexParser.RULE_conditionalExpression; + } + public override enterRule(listener: ApexParserListener): void { + if(listener.enterConditionalExpression) { + listener.enterConditionalExpression(this); + } + } + public override exitRule(listener: ApexParserListener): void { + if(listener.exitConditionalExpression) { + listener.exitConditionalExpression(this); + } + } + public override accept(visitor: ApexParserVisitor): Result | null { + if (visitor.visitConditionalExpression) { + return visitor.visitConditionalExpression(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class FieldExpressionContext extends antlr.ParserRuleContext { + public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { + super(parent, invokingState); + } + public fieldName(): FieldNameContext | null { + return this.getRuleContext(0, FieldNameContext); + } + public comparisonOperator(): ComparisonOperatorContext { + return this.getRuleContext(0, ComparisonOperatorContext)!; + } + public value(): ValueContext { + return this.getRuleContext(0, ValueContext)!; + } + public soqlFunction(): SoqlFunctionContext | null { + return this.getRuleContext(0, SoqlFunctionContext); + } + public override get ruleIndex(): number { + return ApexParser.RULE_fieldExpression; + } + public override enterRule(listener: ApexParserListener): void { + if(listener.enterFieldExpression) { + listener.enterFieldExpression(this); + } + } + public override exitRule(listener: ApexParserListener): void { + if(listener.exitFieldExpression) { + listener.exitFieldExpression(this); + } + } + public override accept(visitor: ApexParserVisitor): Result | null { + if (visitor.visitFieldExpression) { + return visitor.visitFieldExpression(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class ComparisonOperatorContext extends antlr.ParserRuleContext { + public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { + super(parent, invokingState); + } + public ASSIGN(): antlr.TerminalNode | null { + return this.getToken(ApexParser.ASSIGN, 0); + } + public NOTEQUAL(): antlr.TerminalNode | null { + return this.getToken(ApexParser.NOTEQUAL, 0); + } + public LT(): antlr.TerminalNode | null { + return this.getToken(ApexParser.LT, 0); + } + public GT(): antlr.TerminalNode | null { + return this.getToken(ApexParser.GT, 0); + } + public LESSANDGREATER(): antlr.TerminalNode | null { + return this.getToken(ApexParser.LESSANDGREATER, 0); + } + public LIKE(): antlr.TerminalNode | null { + return this.getToken(ApexParser.LIKE, 0); + } + public IN(): antlr.TerminalNode | null { + return this.getToken(ApexParser.IN, 0); + } + public NOT(): antlr.TerminalNode | null { + return this.getToken(ApexParser.NOT, 0); + } + public INCLUDES(): antlr.TerminalNode | null { + return this.getToken(ApexParser.INCLUDES, 0); + } + public EXCLUDES(): antlr.TerminalNode | null { + return this.getToken(ApexParser.EXCLUDES, 0); + } + public override get ruleIndex(): number { + return ApexParser.RULE_comparisonOperator; + } + public override enterRule(listener: ApexParserListener): void { + if(listener.enterComparisonOperator) { + listener.enterComparisonOperator(this); + } + } + public override exitRule(listener: ApexParserListener): void { + if(listener.exitComparisonOperator) { + listener.exitComparisonOperator(this); + } + } + public override accept(visitor: ApexParserVisitor): Result | null { + if (visitor.visitComparisonOperator) { + return visitor.visitComparisonOperator(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class ValueContext extends antlr.ParserRuleContext { + public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { + super(parent, invokingState); + } + public NULL(): antlr.TerminalNode | null { + return this.getToken(ApexParser.NULL, 0); + } + public BooleanLiteral(): antlr.TerminalNode | null { + return this.getToken(ApexParser.BooleanLiteral, 0); + } + public signedNumber(): SignedNumberContext | null { + return this.getRuleContext(0, SignedNumberContext); + } + public StringLiteral(): antlr.TerminalNode | null { + return this.getToken(ApexParser.StringLiteral, 0); + } + public DateLiteral(): antlr.TerminalNode | null { + return this.getToken(ApexParser.DateLiteral, 0); + } + public DateTimeLiteral(): antlr.TerminalNode | null { + return this.getToken(ApexParser.DateTimeLiteral, 0); + } + public dateFormula(): DateFormulaContext | null { + return this.getRuleContext(0, DateFormulaContext); + } + public IntegralCurrencyLiteral(): antlr.TerminalNode | null { + return this.getToken(ApexParser.IntegralCurrencyLiteral, 0); + } + public DOT(): antlr.TerminalNode | null { + return this.getToken(ApexParser.DOT, 0); + } + public IntegerLiteral(): antlr.TerminalNode | null { + return this.getToken(ApexParser.IntegerLiteral, 0); + } + public LPAREN(): antlr.TerminalNode | null { + return this.getToken(ApexParser.LPAREN, 0); + } + public subQuery(): SubQueryContext | null { + return this.getRuleContext(0, SubQueryContext); + } + public RPAREN(): antlr.TerminalNode | null { + return this.getToken(ApexParser.RPAREN, 0); + } + public valueList(): ValueListContext | null { + return this.getRuleContext(0, ValueListContext); + } + public boundExpression(): BoundExpressionContext | null { + return this.getRuleContext(0, BoundExpressionContext); + } + public override get ruleIndex(): number { + return ApexParser.RULE_value; + } + public override enterRule(listener: ApexParserListener): void { + if(listener.enterValue) { + listener.enterValue(this); + } + } + public override exitRule(listener: ApexParserListener): void { + if(listener.exitValue) { + listener.exitValue(this); + } + } + public override accept(visitor: ApexParserVisitor): Result | null { + if (visitor.visitValue) { + return visitor.visitValue(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class ValueListContext extends antlr.ParserRuleContext { + public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { + super(parent, invokingState); + } + public LPAREN(): antlr.TerminalNode { + return this.getToken(ApexParser.LPAREN, 0)!; + } + public value(): ValueContext[]; + public value(i: number): ValueContext | null; + public value(i?: number): ValueContext[] | ValueContext | null { + if (i === undefined) { + return this.getRuleContexts(ValueContext); + } + + return this.getRuleContext(i, ValueContext); + } + public RPAREN(): antlr.TerminalNode { + return this.getToken(ApexParser.RPAREN, 0)!; + } + public COMMA(): antlr.TerminalNode[]; + public COMMA(i: number): antlr.TerminalNode | null; + public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { + if (i === undefined) { + return this.getTokens(ApexParser.COMMA); + } else { + return this.getToken(ApexParser.COMMA, i); + } + } + public override get ruleIndex(): number { + return ApexParser.RULE_valueList; + } + public override enterRule(listener: ApexParserListener): void { + if(listener.enterValueList) { + listener.enterValueList(this); + } + } + public override exitRule(listener: ApexParserListener): void { + if(listener.exitValueList) { + listener.exitValueList(this); + } + } + public override accept(visitor: ApexParserVisitor): Result | null { + if (visitor.visitValueList) { + return visitor.visitValueList(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class SignedNumberContext extends antlr.ParserRuleContext { + public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { + super(parent, invokingState); + } + public IntegerLiteral(): antlr.TerminalNode | null { + return this.getToken(ApexParser.IntegerLiteral, 0); + } + public NumberLiteral(): antlr.TerminalNode | null { + return this.getToken(ApexParser.NumberLiteral, 0); + } + public ADD(): antlr.TerminalNode | null { + return this.getToken(ApexParser.ADD, 0); + } + public SUB(): antlr.TerminalNode | null { + return this.getToken(ApexParser.SUB, 0); + } + public override get ruleIndex(): number { + return ApexParser.RULE_signedNumber; + } + public override enterRule(listener: ApexParserListener): void { + if(listener.enterSignedNumber) { + listener.enterSignedNumber(this); + } + } + public override exitRule(listener: ApexParserListener): void { + if(listener.exitSignedNumber) { + listener.exitSignedNumber(this); + } + } + public override accept(visitor: ApexParserVisitor): Result | null { + if (visitor.visitSignedNumber) { + return visitor.visitSignedNumber(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class WithClauseContext extends antlr.ParserRuleContext { + public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { + super(parent, invokingState); + } + public WITH(): antlr.TerminalNode { + return this.getToken(ApexParser.WITH, 0)!; + } + public DATA(): antlr.TerminalNode | null { + return this.getToken(ApexParser.DATA, 0); + } + public CATEGORY(): antlr.TerminalNode | null { + return this.getToken(ApexParser.CATEGORY, 0); + } + public filteringExpression(): FilteringExpressionContext | null { + return this.getRuleContext(0, FilteringExpressionContext); + } + public SECURITY_ENFORCED(): antlr.TerminalNode | null { + return this.getToken(ApexParser.SECURITY_ENFORCED, 0); + } + public SYSTEM_MODE(): antlr.TerminalNode | null { + return this.getToken(ApexParser.SYSTEM_MODE, 0); + } + public USER_MODE(): antlr.TerminalNode | null { + return this.getToken(ApexParser.USER_MODE, 0); + } + public logicalExpression(): LogicalExpressionContext | null { + return this.getRuleContext(0, LogicalExpressionContext); + } + public override get ruleIndex(): number { + return ApexParser.RULE_withClause; + } + public override enterRule(listener: ApexParserListener): void { + if(listener.enterWithClause) { + listener.enterWithClause(this); + } + } + public override exitRule(listener: ApexParserListener): void { + if(listener.exitWithClause) { + listener.exitWithClause(this); + } + } + public override accept(visitor: ApexParserVisitor): Result | null { + if (visitor.visitWithClause) { + return visitor.visitWithClause(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class FilteringExpressionContext extends antlr.ParserRuleContext { + public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { + super(parent, invokingState); + } + public dataCategorySelection(): DataCategorySelectionContext[]; + public dataCategorySelection(i: number): DataCategorySelectionContext | null; + public dataCategorySelection(i?: number): DataCategorySelectionContext[] | DataCategorySelectionContext | null { + if (i === undefined) { + return this.getRuleContexts(DataCategorySelectionContext); + } + + return this.getRuleContext(i, DataCategorySelectionContext); + } + public AND(): antlr.TerminalNode[]; + public AND(i: number): antlr.TerminalNode | null; + public AND(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { + if (i === undefined) { + return this.getTokens(ApexParser.AND); + } else { + return this.getToken(ApexParser.AND, i); + } + } + public override get ruleIndex(): number { + return ApexParser.RULE_filteringExpression; + } + public override enterRule(listener: ApexParserListener): void { + if(listener.enterFilteringExpression) { + listener.enterFilteringExpression(this); + } + } + public override exitRule(listener: ApexParserListener): void { + if(listener.exitFilteringExpression) { + listener.exitFilteringExpression(this); + } + } + public override accept(visitor: ApexParserVisitor): Result | null { + if (visitor.visitFilteringExpression) { + return visitor.visitFilteringExpression(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class DataCategorySelectionContext extends antlr.ParserRuleContext { + public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { + super(parent, invokingState); + } + public soqlId(): SoqlIdContext { + return this.getRuleContext(0, SoqlIdContext)!; + } + public filteringSelector(): FilteringSelectorContext { + return this.getRuleContext(0, FilteringSelectorContext)!; + } + public dataCategoryName(): DataCategoryNameContext { + return this.getRuleContext(0, DataCategoryNameContext)!; + } + public override get ruleIndex(): number { + return ApexParser.RULE_dataCategorySelection; + } + public override enterRule(listener: ApexParserListener): void { + if(listener.enterDataCategorySelection) { + listener.enterDataCategorySelection(this); + } + } + public override exitRule(listener: ApexParserListener): void { + if(listener.exitDataCategorySelection) { + listener.exitDataCategorySelection(this); + } + } + public override accept(visitor: ApexParserVisitor): Result | null { + if (visitor.visitDataCategorySelection) { + return visitor.visitDataCategorySelection(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class DataCategoryNameContext extends antlr.ParserRuleContext { + public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { + super(parent, invokingState); + } + public soqlId(): SoqlIdContext[]; + public soqlId(i: number): SoqlIdContext | null; + public soqlId(i?: number): SoqlIdContext[] | SoqlIdContext | null { + if (i === undefined) { + return this.getRuleContexts(SoqlIdContext); + } + + return this.getRuleContext(i, SoqlIdContext); + } + public LPAREN(): antlr.TerminalNode[]; + public LPAREN(i: number): antlr.TerminalNode | null; + public LPAREN(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { + if (i === undefined) { + return this.getTokens(ApexParser.LPAREN); + } else { + return this.getToken(ApexParser.LPAREN, i); + } + } + public COMMA(): antlr.TerminalNode[]; + public COMMA(i: number): antlr.TerminalNode | null; + public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { + if (i === undefined) { + return this.getTokens(ApexParser.COMMA); + } else { + return this.getToken(ApexParser.COMMA, i); + } + } + public override get ruleIndex(): number { + return ApexParser.RULE_dataCategoryName; + } + public override enterRule(listener: ApexParserListener): void { + if(listener.enterDataCategoryName) { + listener.enterDataCategoryName(this); + } + } + public override exitRule(listener: ApexParserListener): void { + if(listener.exitDataCategoryName) { + listener.exitDataCategoryName(this); + } + } + public override accept(visitor: ApexParserVisitor): Result | null { + if (visitor.visitDataCategoryName) { + return visitor.visitDataCategoryName(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class FilteringSelectorContext extends antlr.ParserRuleContext { + public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { + super(parent, invokingState); + } + public AT(): antlr.TerminalNode | null { + return this.getToken(ApexParser.AT, 0); + } + public ABOVE(): antlr.TerminalNode | null { + return this.getToken(ApexParser.ABOVE, 0); + } + public BELOW(): antlr.TerminalNode | null { + return this.getToken(ApexParser.BELOW, 0); + } + public ABOVE_OR_BELOW(): antlr.TerminalNode | null { + return this.getToken(ApexParser.ABOVE_OR_BELOW, 0); + } + public override get ruleIndex(): number { + return ApexParser.RULE_filteringSelector; + } + public override enterRule(listener: ApexParserListener): void { + if(listener.enterFilteringSelector) { + listener.enterFilteringSelector(this); + } + } + public override exitRule(listener: ApexParserListener): void { + if(listener.exitFilteringSelector) { + listener.exitFilteringSelector(this); + } + } + public override accept(visitor: ApexParserVisitor): Result | null { + if (visitor.visitFilteringSelector) { + return visitor.visitFilteringSelector(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class GroupByClauseContext extends antlr.ParserRuleContext { + public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { + super(parent, invokingState); + } + public GROUP(): antlr.TerminalNode { + return this.getToken(ApexParser.GROUP, 0)!; + } + public BY(): antlr.TerminalNode { + return this.getToken(ApexParser.BY, 0)!; + } + public selectList(): SelectListContext | null { + return this.getRuleContext(0, SelectListContext); + } + public HAVING(): antlr.TerminalNode | null { + return this.getToken(ApexParser.HAVING, 0); + } + public logicalExpression(): LogicalExpressionContext | null { + return this.getRuleContext(0, LogicalExpressionContext); + } + public ROLLUP(): antlr.TerminalNode | null { + return this.getToken(ApexParser.ROLLUP, 0); + } + public LPAREN(): antlr.TerminalNode | null { + return this.getToken(ApexParser.LPAREN, 0); + } + public fieldName(): FieldNameContext[]; + public fieldName(i: number): FieldNameContext | null; + public fieldName(i?: number): FieldNameContext[] | FieldNameContext | null { + if (i === undefined) { + return this.getRuleContexts(FieldNameContext); + } + + return this.getRuleContext(i, FieldNameContext); + } + public RPAREN(): antlr.TerminalNode | null { + return this.getToken(ApexParser.RPAREN, 0); + } + public COMMA(): antlr.TerminalNode[]; + public COMMA(i: number): antlr.TerminalNode | null; + public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { + if (i === undefined) { + return this.getTokens(ApexParser.COMMA); + } else { + return this.getToken(ApexParser.COMMA, i); + } + } + public CUBE(): antlr.TerminalNode | null { + return this.getToken(ApexParser.CUBE, 0); + } + public override get ruleIndex(): number { + return ApexParser.RULE_groupByClause; + } + public override enterRule(listener: ApexParserListener): void { + if(listener.enterGroupByClause) { + listener.enterGroupByClause(this); + } + } + public override exitRule(listener: ApexParserListener): void { + if(listener.exitGroupByClause) { + listener.exitGroupByClause(this); + } + } + public override accept(visitor: ApexParserVisitor): Result | null { + if (visitor.visitGroupByClause) { + return visitor.visitGroupByClause(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class OrderByClauseContext extends antlr.ParserRuleContext { + public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { + super(parent, invokingState); + } + public ORDER(): antlr.TerminalNode { + return this.getToken(ApexParser.ORDER, 0)!; + } + public BY(): antlr.TerminalNode { + return this.getToken(ApexParser.BY, 0)!; + } + public fieldOrderList(): FieldOrderListContext { + return this.getRuleContext(0, FieldOrderListContext)!; + } + public override get ruleIndex(): number { + return ApexParser.RULE_orderByClause; + } + public override enterRule(listener: ApexParserListener): void { + if(listener.enterOrderByClause) { + listener.enterOrderByClause(this); + } + } + public override exitRule(listener: ApexParserListener): void { + if(listener.exitOrderByClause) { + listener.exitOrderByClause(this); + } + } + public override accept(visitor: ApexParserVisitor): Result | null { + if (visitor.visitOrderByClause) { + return visitor.visitOrderByClause(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class FieldOrderListContext extends antlr.ParserRuleContext { + public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { + super(parent, invokingState); + } + public fieldOrder(): FieldOrderContext[]; + public fieldOrder(i: number): FieldOrderContext | null; + public fieldOrder(i?: number): FieldOrderContext[] | FieldOrderContext | null { + if (i === undefined) { + return this.getRuleContexts(FieldOrderContext); + } + + return this.getRuleContext(i, FieldOrderContext); + } + public COMMA(): antlr.TerminalNode[]; + public COMMA(i: number): antlr.TerminalNode | null; + public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { + if (i === undefined) { + return this.getTokens(ApexParser.COMMA); + } else { + return this.getToken(ApexParser.COMMA, i); + } + } + public override get ruleIndex(): number { + return ApexParser.RULE_fieldOrderList; + } + public override enterRule(listener: ApexParserListener): void { + if(listener.enterFieldOrderList) { + listener.enterFieldOrderList(this); + } + } + public override exitRule(listener: ApexParserListener): void { + if(listener.exitFieldOrderList) { + listener.exitFieldOrderList(this); + } + } + public override accept(visitor: ApexParserVisitor): Result | null { + if (visitor.visitFieldOrderList) { + return visitor.visitFieldOrderList(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class FieldOrderContext extends antlr.ParserRuleContext { + public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { + super(parent, invokingState); + } + public fieldName(): FieldNameContext | null { + return this.getRuleContext(0, FieldNameContext); + } + public NULLS(): antlr.TerminalNode | null { + return this.getToken(ApexParser.NULLS, 0); + } + public ASC(): antlr.TerminalNode | null { + return this.getToken(ApexParser.ASC, 0); + } + public DESC(): antlr.TerminalNode | null { + return this.getToken(ApexParser.DESC, 0); + } + public FIRST(): antlr.TerminalNode | null { + return this.getToken(ApexParser.FIRST, 0); + } + public LAST(): antlr.TerminalNode | null { + return this.getToken(ApexParser.LAST, 0); + } + public soqlFunction(): SoqlFunctionContext | null { + return this.getRuleContext(0, SoqlFunctionContext); + } + public override get ruleIndex(): number { + return ApexParser.RULE_fieldOrder; + } + public override enterRule(listener: ApexParserListener): void { + if(listener.enterFieldOrder) { + listener.enterFieldOrder(this); + } + } + public override exitRule(listener: ApexParserListener): void { + if(listener.exitFieldOrder) { + listener.exitFieldOrder(this); + } + } + public override accept(visitor: ApexParserVisitor): Result | null { + if (visitor.visitFieldOrder) { + return visitor.visitFieldOrder(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class LimitClauseContext extends antlr.ParserRuleContext { + public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { + super(parent, invokingState); + } + public LIMIT(): antlr.TerminalNode { + return this.getToken(ApexParser.LIMIT, 0)!; + } + public IntegerLiteral(): antlr.TerminalNode | null { + return this.getToken(ApexParser.IntegerLiteral, 0); + } + public boundExpression(): BoundExpressionContext | null { + return this.getRuleContext(0, BoundExpressionContext); + } + public override get ruleIndex(): number { + return ApexParser.RULE_limitClause; + } + public override enterRule(listener: ApexParserListener): void { + if(listener.enterLimitClause) { + listener.enterLimitClause(this); + } + } + public override exitRule(listener: ApexParserListener): void { + if(listener.exitLimitClause) { + listener.exitLimitClause(this); + } + } + public override accept(visitor: ApexParserVisitor): Result | null { + if (visitor.visitLimitClause) { + return visitor.visitLimitClause(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class OffsetClauseContext extends antlr.ParserRuleContext { + public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { + super(parent, invokingState); + } + public OFFSET(): antlr.TerminalNode { + return this.getToken(ApexParser.OFFSET, 0)!; + } + public IntegerLiteral(): antlr.TerminalNode | null { + return this.getToken(ApexParser.IntegerLiteral, 0); + } + public boundExpression(): BoundExpressionContext | null { + return this.getRuleContext(0, BoundExpressionContext); + } + public override get ruleIndex(): number { + return ApexParser.RULE_offsetClause; + } + public override enterRule(listener: ApexParserListener): void { + if(listener.enterOffsetClause) { + listener.enterOffsetClause(this); + } + } + public override exitRule(listener: ApexParserListener): void { + if(listener.exitOffsetClause) { + listener.exitOffsetClause(this); + } + } + public override accept(visitor: ApexParserVisitor): Result | null { + if (visitor.visitOffsetClause) { + return visitor.visitOffsetClause(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class AllRowsClauseContext extends antlr.ParserRuleContext { + public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { + super(parent, invokingState); + } + public ALL(): antlr.TerminalNode { + return this.getToken(ApexParser.ALL, 0)!; + } + public ROWS(): antlr.TerminalNode { + return this.getToken(ApexParser.ROWS, 0)!; + } + public override get ruleIndex(): number { + return ApexParser.RULE_allRowsClause; + } + public override enterRule(listener: ApexParserListener): void { + if(listener.enterAllRowsClause) { + listener.enterAllRowsClause(this); + } + } + public override exitRule(listener: ApexParserListener): void { + if(listener.exitAllRowsClause) { + listener.exitAllRowsClause(this); + } + } + public override accept(visitor: ApexParserVisitor): Result | null { + if (visitor.visitAllRowsClause) { + return visitor.visitAllRowsClause(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class ForClausesContext extends antlr.ParserRuleContext { + public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { + super(parent, invokingState); + } + public FOR(): antlr.TerminalNode[]; + public FOR(i: number): antlr.TerminalNode | null; + public FOR(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { + if (i === undefined) { + return this.getTokens(ApexParser.FOR); + } else { + return this.getToken(ApexParser.FOR, i); + } + } + public VIEW(): antlr.TerminalNode[]; + public VIEW(i: number): antlr.TerminalNode | null; + public VIEW(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { + if (i === undefined) { + return this.getTokens(ApexParser.VIEW); + } else { + return this.getToken(ApexParser.VIEW, i); + } + } + public UPDATE(): antlr.TerminalNode[]; + public UPDATE(i: number): antlr.TerminalNode | null; + public UPDATE(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { + if (i === undefined) { + return this.getTokens(ApexParser.UPDATE); + } else { + return this.getToken(ApexParser.UPDATE, i); + } + } + public REFERENCE(): antlr.TerminalNode[]; + public REFERENCE(i: number): antlr.TerminalNode | null; + public REFERENCE(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { + if (i === undefined) { + return this.getTokens(ApexParser.REFERENCE); + } else { + return this.getToken(ApexParser.REFERENCE, i); + } + } + public override get ruleIndex(): number { + return ApexParser.RULE_forClauses; + } + public override enterRule(listener: ApexParserListener): void { + if(listener.enterForClauses) { + listener.enterForClauses(this); + } + } + public override exitRule(listener: ApexParserListener): void { + if(listener.exitForClauses) { + listener.exitForClauses(this); + } + } + public override accept(visitor: ApexParserVisitor): Result | null { + if (visitor.visitForClauses) { + return visitor.visitForClauses(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class BoundExpressionContext extends antlr.ParserRuleContext { + public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { + super(parent, invokingState); + } + public COLON(): antlr.TerminalNode { + return this.getToken(ApexParser.COLON, 0)!; + } + public expression(): ExpressionContext { + return this.getRuleContext(0, ExpressionContext)!; + } + public override get ruleIndex(): number { + return ApexParser.RULE_boundExpression; + } + public override enterRule(listener: ApexParserListener): void { + if(listener.enterBoundExpression) { + listener.enterBoundExpression(this); + } + } + public override exitRule(listener: ApexParserListener): void { + if(listener.exitBoundExpression) { + listener.exitBoundExpression(this); + } + } + public override accept(visitor: ApexParserVisitor): Result | null { + if (visitor.visitBoundExpression) { + return visitor.visitBoundExpression(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class DateFormulaContext extends antlr.ParserRuleContext { + public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { + super(parent, invokingState); + } + public YESTERDAY(): antlr.TerminalNode | null { + return this.getToken(ApexParser.YESTERDAY, 0); + } + public TODAY(): antlr.TerminalNode | null { + return this.getToken(ApexParser.TODAY, 0); + } + public TOMORROW(): antlr.TerminalNode | null { + return this.getToken(ApexParser.TOMORROW, 0); + } + public LAST_WEEK(): antlr.TerminalNode | null { + return this.getToken(ApexParser.LAST_WEEK, 0); + } + public THIS_WEEK(): antlr.TerminalNode | null { + return this.getToken(ApexParser.THIS_WEEK, 0); + } + public NEXT_WEEK(): antlr.TerminalNode | null { + return this.getToken(ApexParser.NEXT_WEEK, 0); + } + public LAST_MONTH(): antlr.TerminalNode | null { + return this.getToken(ApexParser.LAST_MONTH, 0); + } + public THIS_MONTH(): antlr.TerminalNode | null { + return this.getToken(ApexParser.THIS_MONTH, 0); + } + public NEXT_MONTH(): antlr.TerminalNode | null { + return this.getToken(ApexParser.NEXT_MONTH, 0); + } + public LAST_90_DAYS(): antlr.TerminalNode | null { + return this.getToken(ApexParser.LAST_90_DAYS, 0); + } + public NEXT_90_DAYS(): antlr.TerminalNode | null { + return this.getToken(ApexParser.NEXT_90_DAYS, 0); + } + public LAST_N_DAYS_N(): antlr.TerminalNode | null { + return this.getToken(ApexParser.LAST_N_DAYS_N, 0); + } + public COLON(): antlr.TerminalNode | null { + return this.getToken(ApexParser.COLON, 0); + } + public signedInteger(): SignedIntegerContext | null { + return this.getRuleContext(0, SignedIntegerContext); + } + public NEXT_N_DAYS_N(): antlr.TerminalNode | null { + return this.getToken(ApexParser.NEXT_N_DAYS_N, 0); + } + public N_DAYS_AGO_N(): antlr.TerminalNode | null { + return this.getToken(ApexParser.N_DAYS_AGO_N, 0); + } + public NEXT_N_WEEKS_N(): antlr.TerminalNode | null { + return this.getToken(ApexParser.NEXT_N_WEEKS_N, 0); + } + public LAST_N_WEEKS_N(): antlr.TerminalNode | null { + return this.getToken(ApexParser.LAST_N_WEEKS_N, 0); + } + public N_WEEKS_AGO_N(): antlr.TerminalNode | null { + return this.getToken(ApexParser.N_WEEKS_AGO_N, 0); + } + public NEXT_N_MONTHS_N(): antlr.TerminalNode | null { + return this.getToken(ApexParser.NEXT_N_MONTHS_N, 0); + } + public LAST_N_MONTHS_N(): antlr.TerminalNode | null { + return this.getToken(ApexParser.LAST_N_MONTHS_N, 0); + } + public N_MONTHS_AGO_N(): antlr.TerminalNode | null { + return this.getToken(ApexParser.N_MONTHS_AGO_N, 0); + } + public THIS_QUARTER(): antlr.TerminalNode | null { + return this.getToken(ApexParser.THIS_QUARTER, 0); + } + public LAST_QUARTER(): antlr.TerminalNode | null { + return this.getToken(ApexParser.LAST_QUARTER, 0); + } + public NEXT_QUARTER(): antlr.TerminalNode | null { + return this.getToken(ApexParser.NEXT_QUARTER, 0); + } + public NEXT_N_QUARTERS_N(): antlr.TerminalNode | null { + return this.getToken(ApexParser.NEXT_N_QUARTERS_N, 0); + } + public LAST_N_QUARTERS_N(): antlr.TerminalNode | null { + return this.getToken(ApexParser.LAST_N_QUARTERS_N, 0); + } + public N_QUARTERS_AGO_N(): antlr.TerminalNode | null { + return this.getToken(ApexParser.N_QUARTERS_AGO_N, 0); + } + public THIS_YEAR(): antlr.TerminalNode | null { + return this.getToken(ApexParser.THIS_YEAR, 0); + } + public LAST_YEAR(): antlr.TerminalNode | null { + return this.getToken(ApexParser.LAST_YEAR, 0); + } + public NEXT_YEAR(): antlr.TerminalNode | null { + return this.getToken(ApexParser.NEXT_YEAR, 0); + } + public NEXT_N_YEARS_N(): antlr.TerminalNode | null { + return this.getToken(ApexParser.NEXT_N_YEARS_N, 0); + } + public LAST_N_YEARS_N(): antlr.TerminalNode | null { + return this.getToken(ApexParser.LAST_N_YEARS_N, 0); + } + public N_YEARS_AGO_N(): antlr.TerminalNode | null { + return this.getToken(ApexParser.N_YEARS_AGO_N, 0); + } + public THIS_FISCAL_QUARTER(): antlr.TerminalNode | null { + return this.getToken(ApexParser.THIS_FISCAL_QUARTER, 0); + } + public LAST_FISCAL_QUARTER(): antlr.TerminalNode | null { + return this.getToken(ApexParser.LAST_FISCAL_QUARTER, 0); + } + public NEXT_FISCAL_QUARTER(): antlr.TerminalNode | null { + return this.getToken(ApexParser.NEXT_FISCAL_QUARTER, 0); + } + public NEXT_N_FISCAL_QUARTERS_N(): antlr.TerminalNode | null { + return this.getToken(ApexParser.NEXT_N_FISCAL_QUARTERS_N, 0); + } + public LAST_N_FISCAL_QUARTERS_N(): antlr.TerminalNode | null { + return this.getToken(ApexParser.LAST_N_FISCAL_QUARTERS_N, 0); + } + public N_FISCAL_QUARTERS_AGO_N(): antlr.TerminalNode | null { + return this.getToken(ApexParser.N_FISCAL_QUARTERS_AGO_N, 0); + } + public THIS_FISCAL_YEAR(): antlr.TerminalNode | null { + return this.getToken(ApexParser.THIS_FISCAL_YEAR, 0); + } + public LAST_FISCAL_YEAR(): antlr.TerminalNode | null { + return this.getToken(ApexParser.LAST_FISCAL_YEAR, 0); + } + public NEXT_FISCAL_YEAR(): antlr.TerminalNode | null { + return this.getToken(ApexParser.NEXT_FISCAL_YEAR, 0); + } + public NEXT_N_FISCAL_YEARS_N(): antlr.TerminalNode | null { + return this.getToken(ApexParser.NEXT_N_FISCAL_YEARS_N, 0); + } + public LAST_N_FISCAL_YEARS_N(): antlr.TerminalNode | null { + return this.getToken(ApexParser.LAST_N_FISCAL_YEARS_N, 0); + } + public N_FISCAL_YEARS_AGO_N(): antlr.TerminalNode | null { + return this.getToken(ApexParser.N_FISCAL_YEARS_AGO_N, 0); + } + public override get ruleIndex(): number { + return ApexParser.RULE_dateFormula; + } + public override enterRule(listener: ApexParserListener): void { + if(listener.enterDateFormula) { + listener.enterDateFormula(this); + } + } + public override exitRule(listener: ApexParserListener): void { + if(listener.exitDateFormula) { + listener.exitDateFormula(this); + } + } + public override accept(visitor: ApexParserVisitor): Result | null { + if (visitor.visitDateFormula) { + return visitor.visitDateFormula(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class SignedIntegerContext extends antlr.ParserRuleContext { + public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { + super(parent, invokingState); + } + public IntegerLiteral(): antlr.TerminalNode { + return this.getToken(ApexParser.IntegerLiteral, 0)!; + } + public ADD(): antlr.TerminalNode | null { + return this.getToken(ApexParser.ADD, 0); + } + public SUB(): antlr.TerminalNode | null { + return this.getToken(ApexParser.SUB, 0); + } + public override get ruleIndex(): number { + return ApexParser.RULE_signedInteger; + } + public override enterRule(listener: ApexParserListener): void { + if(listener.enterSignedInteger) { + listener.enterSignedInteger(this); + } + } + public override exitRule(listener: ApexParserListener): void { + if(listener.exitSignedInteger) { + listener.exitSignedInteger(this); + } + } + public override accept(visitor: ApexParserVisitor): Result | null { + if (visitor.visitSignedInteger) { + return visitor.visitSignedInteger(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class SoqlIdContext extends antlr.ParserRuleContext { + public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { + super(parent, invokingState); + } + public id(): IdContext { + return this.getRuleContext(0, IdContext)!; + } + public override get ruleIndex(): number { + return ApexParser.RULE_soqlId; + } + public override enterRule(listener: ApexParserListener): void { + if(listener.enterSoqlId) { + listener.enterSoqlId(this); + } + } + public override exitRule(listener: ApexParserListener): void { + if(listener.exitSoqlId) { + listener.exitSoqlId(this); + } + } + public override accept(visitor: ApexParserVisitor): Result | null { + if (visitor.visitSoqlId) { + return visitor.visitSoqlId(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class SoslLiteralContext extends antlr.ParserRuleContext { + public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { + super(parent, invokingState); + } + public FindLiteral(): antlr.TerminalNode | null { + return this.getToken(ApexParser.FindLiteral, 0); + } + public soslClauses(): SoslClausesContext { + return this.getRuleContext(0, SoslClausesContext)!; + } + public RBRACK(): antlr.TerminalNode { + return this.getToken(ApexParser.RBRACK, 0)!; + } + public LBRACK(): antlr.TerminalNode | null { + return this.getToken(ApexParser.LBRACK, 0); + } + public FIND(): antlr.TerminalNode | null { + return this.getToken(ApexParser.FIND, 0); + } + public boundExpression(): BoundExpressionContext | null { + return this.getRuleContext(0, BoundExpressionContext); + } + public override get ruleIndex(): number { + return ApexParser.RULE_soslLiteral; + } + public override enterRule(listener: ApexParserListener): void { + if(listener.enterSoslLiteral) { + listener.enterSoslLiteral(this); + } + } + public override exitRule(listener: ApexParserListener): void { + if(listener.exitSoslLiteral) { + listener.exitSoslLiteral(this); + } + } + public override accept(visitor: ApexParserVisitor): Result | null { + if (visitor.visitSoslLiteral) { + return visitor.visitSoslLiteral(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class SoslLiteralAltContext extends antlr.ParserRuleContext { + public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { + super(parent, invokingState); + } + public FindLiteralAlt(): antlr.TerminalNode { + return this.getToken(ApexParser.FindLiteralAlt, 0)!; + } + public soslClauses(): SoslClausesContext { + return this.getRuleContext(0, SoslClausesContext)!; + } + public RBRACK(): antlr.TerminalNode { + return this.getToken(ApexParser.RBRACK, 0)!; + } + public override get ruleIndex(): number { + return ApexParser.RULE_soslLiteralAlt; + } + public override enterRule(listener: ApexParserListener): void { + if(listener.enterSoslLiteralAlt) { + listener.enterSoslLiteralAlt(this); + } + } + public override exitRule(listener: ApexParserListener): void { + if(listener.exitSoslLiteralAlt) { + listener.exitSoslLiteralAlt(this); + } + } + public override accept(visitor: ApexParserVisitor): Result | null { + if (visitor.visitSoslLiteralAlt) { + return visitor.visitSoslLiteralAlt(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class SoslClausesContext extends antlr.ParserRuleContext { + public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { + super(parent, invokingState); + } + public IN(): antlr.TerminalNode[]; + public IN(i: number): antlr.TerminalNode | null; + public IN(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { + if (i === undefined) { + return this.getTokens(ApexParser.IN); + } else { + return this.getToken(ApexParser.IN, i); + } + } + public searchGroup(): SearchGroupContext | null { + return this.getRuleContext(0, SearchGroupContext); + } + public RETURNING(): antlr.TerminalNode | null { + return this.getToken(ApexParser.RETURNING, 0); + } + public fieldSpecList(): FieldSpecListContext | null { + return this.getRuleContext(0, FieldSpecListContext); + } + public WITH(): antlr.TerminalNode[]; + public WITH(i: number): antlr.TerminalNode | null; + public WITH(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { + if (i === undefined) { + return this.getTokens(ApexParser.WITH); + } else { + return this.getToken(ApexParser.WITH, i); + } + } + public DIVISION(): antlr.TerminalNode | null { + return this.getToken(ApexParser.DIVISION, 0); + } + public ASSIGN(): antlr.TerminalNode[]; + public ASSIGN(i: number): antlr.TerminalNode | null; + public ASSIGN(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { + if (i === undefined) { + return this.getTokens(ApexParser.ASSIGN); + } else { + return this.getToken(ApexParser.ASSIGN, i); + } + } + public StringLiteral(): antlr.TerminalNode[]; + public StringLiteral(i: number): antlr.TerminalNode | null; + public StringLiteral(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { + if (i === undefined) { + return this.getTokens(ApexParser.StringLiteral); + } else { + return this.getToken(ApexParser.StringLiteral, i); + } + } + public DATA(): antlr.TerminalNode | null { + return this.getToken(ApexParser.DATA, 0); + } + public CATEGORY(): antlr.TerminalNode | null { + return this.getToken(ApexParser.CATEGORY, 0); + } + public filteringExpression(): FilteringExpressionContext | null { + return this.getRuleContext(0, FilteringExpressionContext); + } + public SNIPPET(): antlr.TerminalNode | null { + return this.getToken(ApexParser.SNIPPET, 0); + } + public NETWORK(): antlr.TerminalNode[]; + public NETWORK(i: number): antlr.TerminalNode | null; + public NETWORK(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { + if (i === undefined) { + return this.getTokens(ApexParser.NETWORK); + } else { + return this.getToken(ApexParser.NETWORK, i); + } + } + public LPAREN(): antlr.TerminalNode[]; + public LPAREN(i: number): antlr.TerminalNode | null; + public LPAREN(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { + if (i === undefined) { + return this.getTokens(ApexParser.LPAREN); + } else { + return this.getToken(ApexParser.LPAREN, i); + } + } + public networkList(): NetworkListContext | null { + return this.getRuleContext(0, NetworkListContext); + } + public RPAREN(): antlr.TerminalNode[]; + public RPAREN(i: number): antlr.TerminalNode | null; + public RPAREN(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { + if (i === undefined) { + return this.getTokens(ApexParser.RPAREN); + } else { + return this.getToken(ApexParser.RPAREN, i); + } + } + public PRICEBOOKID(): antlr.TerminalNode | null { + return this.getToken(ApexParser.PRICEBOOKID, 0); + } + public METADATA(): antlr.TerminalNode | null { + return this.getToken(ApexParser.METADATA, 0); + } + public limitClause(): LimitClauseContext | null { + return this.getRuleContext(0, LimitClauseContext); + } + public UPDATE(): antlr.TerminalNode | null { + return this.getToken(ApexParser.UPDATE, 0); + } + public updateList(): UpdateListContext | null { + return this.getRuleContext(0, UpdateListContext); + } + public TARGET_LENGTH(): antlr.TerminalNode | null { + return this.getToken(ApexParser.TARGET_LENGTH, 0); + } + public IntegerLiteral(): antlr.TerminalNode | null { + return this.getToken(ApexParser.IntegerLiteral, 0); + } + public override get ruleIndex(): number { + return ApexParser.RULE_soslClauses; + } + public override enterRule(listener: ApexParserListener): void { + if(listener.enterSoslClauses) { + listener.enterSoslClauses(this); + } + } + public override exitRule(listener: ApexParserListener): void { + if(listener.exitSoslClauses) { + listener.exitSoslClauses(this); + } + } + public override accept(visitor: ApexParserVisitor): Result | null { + if (visitor.visitSoslClauses) { + return visitor.visitSoslClauses(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class SearchGroupContext extends antlr.ParserRuleContext { + public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { + super(parent, invokingState); + } + public FIELDS(): antlr.TerminalNode { + return this.getToken(ApexParser.FIELDS, 0)!; + } + public ALL(): antlr.TerminalNode | null { + return this.getToken(ApexParser.ALL, 0); + } + public EMAIL(): antlr.TerminalNode | null { + return this.getToken(ApexParser.EMAIL, 0); + } + public NAME(): antlr.TerminalNode | null { + return this.getToken(ApexParser.NAME, 0); + } + public PHONE(): antlr.TerminalNode | null { + return this.getToken(ApexParser.PHONE, 0); + } + public SIDEBAR(): antlr.TerminalNode | null { + return this.getToken(ApexParser.SIDEBAR, 0); + } + public override get ruleIndex(): number { + return ApexParser.RULE_searchGroup; + } + public override enterRule(listener: ApexParserListener): void { + if(listener.enterSearchGroup) { + listener.enterSearchGroup(this); + } + } + public override exitRule(listener: ApexParserListener): void { + if(listener.exitSearchGroup) { + listener.exitSearchGroup(this); + } + } + public override accept(visitor: ApexParserVisitor): Result | null { + if (visitor.visitSearchGroup) { + return visitor.visitSearchGroup(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class FieldSpecListContext extends antlr.ParserRuleContext { + public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { + super(parent, invokingState); + } + public fieldSpec(): FieldSpecContext { + return this.getRuleContext(0, FieldSpecContext)!; + } + public COMMA(): antlr.TerminalNode[]; + public COMMA(i: number): antlr.TerminalNode | null; + public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { + if (i === undefined) { + return this.getTokens(ApexParser.COMMA); + } else { + return this.getToken(ApexParser.COMMA, i); + } + } + public fieldSpecList(): FieldSpecListContext[]; + public fieldSpecList(i: number): FieldSpecListContext | null; + public fieldSpecList(i?: number): FieldSpecListContext[] | FieldSpecListContext | null { + if (i === undefined) { + return this.getRuleContexts(FieldSpecListContext); + } + + return this.getRuleContext(i, FieldSpecListContext); + } + public override get ruleIndex(): number { + return ApexParser.RULE_fieldSpecList; + } + public override enterRule(listener: ApexParserListener): void { + if(listener.enterFieldSpecList) { + listener.enterFieldSpecList(this); + } + } + public override exitRule(listener: ApexParserListener): void { + if(listener.exitFieldSpecList) { + listener.exitFieldSpecList(this); + } + } + public override accept(visitor: ApexParserVisitor): Result | null { + if (visitor.visitFieldSpecList) { + return visitor.visitFieldSpecList(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class FieldSpecContext extends antlr.ParserRuleContext { + public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { + super(parent, invokingState); + } + public soslId(): SoslIdContext[]; + public soslId(i: number): SoslIdContext | null; + public soslId(i?: number): SoslIdContext[] | SoslIdContext | null { + if (i === undefined) { + return this.getRuleContexts(SoslIdContext); + } + + return this.getRuleContext(i, SoslIdContext); + } + public LPAREN(): antlr.TerminalNode | null { + return this.getToken(ApexParser.LPAREN, 0); + } + public fieldList(): FieldListContext | null { + return this.getRuleContext(0, FieldListContext); + } + public RPAREN(): antlr.TerminalNode | null { + return this.getToken(ApexParser.RPAREN, 0); + } + public WHERE(): antlr.TerminalNode | null { + return this.getToken(ApexParser.WHERE, 0); + } + public logicalExpression(): LogicalExpressionContext | null { + return this.getRuleContext(0, LogicalExpressionContext); + } + public USING(): antlr.TerminalNode | null { + return this.getToken(ApexParser.USING, 0); + } + public LISTVIEW(): antlr.TerminalNode | null { + return this.getToken(ApexParser.LISTVIEW, 0); + } + public ASSIGN(): antlr.TerminalNode | null { + return this.getToken(ApexParser.ASSIGN, 0); + } + public ORDER(): antlr.TerminalNode | null { + return this.getToken(ApexParser.ORDER, 0); + } + public BY(): antlr.TerminalNode | null { + return this.getToken(ApexParser.BY, 0); + } + public fieldOrderList(): FieldOrderListContext | null { + return this.getRuleContext(0, FieldOrderListContext); + } + public limitClause(): LimitClauseContext | null { + return this.getRuleContext(0, LimitClauseContext); + } + public offsetClause(): OffsetClauseContext | null { + return this.getRuleContext(0, OffsetClauseContext); + } + public override get ruleIndex(): number { + return ApexParser.RULE_fieldSpec; + } + public override enterRule(listener: ApexParserListener): void { + if(listener.enterFieldSpec) { + listener.enterFieldSpec(this); + } + } + public override exitRule(listener: ApexParserListener): void { + if(listener.exitFieldSpec) { + listener.exitFieldSpec(this); + } + } + public override accept(visitor: ApexParserVisitor): Result | null { + if (visitor.visitFieldSpec) { + return visitor.visitFieldSpec(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class FieldListContext extends antlr.ParserRuleContext { + public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { + super(parent, invokingState); + } + public soslId(): SoslIdContext { + return this.getRuleContext(0, SoslIdContext)!; + } + public COMMA(): antlr.TerminalNode[]; + public COMMA(i: number): antlr.TerminalNode | null; + public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { + if (i === undefined) { + return this.getTokens(ApexParser.COMMA); + } else { + return this.getToken(ApexParser.COMMA, i); + } + } + public fieldList(): FieldListContext[]; + public fieldList(i: number): FieldListContext | null; + public fieldList(i?: number): FieldListContext[] | FieldListContext | null { + if (i === undefined) { + return this.getRuleContexts(FieldListContext); + } + + return this.getRuleContext(i, FieldListContext); + } + public override get ruleIndex(): number { + return ApexParser.RULE_fieldList; + } + public override enterRule(listener: ApexParserListener): void { + if(listener.enterFieldList) { + listener.enterFieldList(this); + } + } + public override exitRule(listener: ApexParserListener): void { + if(listener.exitFieldList) { + listener.exitFieldList(this); + } + } + public override accept(visitor: ApexParserVisitor): Result | null { + if (visitor.visitFieldList) { + return visitor.visitFieldList(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class UpdateListContext extends antlr.ParserRuleContext { + public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { + super(parent, invokingState); + } + public updateType(): UpdateTypeContext { + return this.getRuleContext(0, UpdateTypeContext)!; + } + public COMMA(): antlr.TerminalNode | null { + return this.getToken(ApexParser.COMMA, 0); + } + public updateList(): UpdateListContext | null { + return this.getRuleContext(0, UpdateListContext); + } + public override get ruleIndex(): number { + return ApexParser.RULE_updateList; + } + public override enterRule(listener: ApexParserListener): void { + if(listener.enterUpdateList) { + listener.enterUpdateList(this); + } + } + public override exitRule(listener: ApexParserListener): void { + if(listener.exitUpdateList) { + listener.exitUpdateList(this); + } + } + public override accept(visitor: ApexParserVisitor): Result | null { + if (visitor.visitUpdateList) { + return visitor.visitUpdateList(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class UpdateTypeContext extends antlr.ParserRuleContext { + public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { + super(parent, invokingState); + } + public TRACKING(): antlr.TerminalNode | null { + return this.getToken(ApexParser.TRACKING, 0); + } + public VIEWSTAT(): antlr.TerminalNode | null { + return this.getToken(ApexParser.VIEWSTAT, 0); + } + public override get ruleIndex(): number { + return ApexParser.RULE_updateType; + } + public override enterRule(listener: ApexParserListener): void { + if(listener.enterUpdateType) { + listener.enterUpdateType(this); + } + } + public override exitRule(listener: ApexParserListener): void { + if(listener.exitUpdateType) { + listener.exitUpdateType(this); + } + } + public override accept(visitor: ApexParserVisitor): Result | null { + if (visitor.visitUpdateType) { + return visitor.visitUpdateType(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class NetworkListContext extends antlr.ParserRuleContext { + public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { + super(parent, invokingState); + } + public StringLiteral(): antlr.TerminalNode { + return this.getToken(ApexParser.StringLiteral, 0)!; + } + public COMMA(): antlr.TerminalNode | null { + return this.getToken(ApexParser.COMMA, 0); + } + public networkList(): NetworkListContext | null { + return this.getRuleContext(0, NetworkListContext); + } + public override get ruleIndex(): number { + return ApexParser.RULE_networkList; + } + public override enterRule(listener: ApexParserListener): void { + if(listener.enterNetworkList) { + listener.enterNetworkList(this); + } + } + public override exitRule(listener: ApexParserListener): void { + if(listener.exitNetworkList) { + listener.exitNetworkList(this); + } + } + public override accept(visitor: ApexParserVisitor): Result | null { + if (visitor.visitNetworkList) { + return visitor.visitNetworkList(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class SoslIdContext extends antlr.ParserRuleContext { + public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { + super(parent, invokingState); + } + public id(): IdContext { + return this.getRuleContext(0, IdContext)!; + } + public DOT(): antlr.TerminalNode[]; + public DOT(i: number): antlr.TerminalNode | null; + public DOT(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { + if (i === undefined) { + return this.getTokens(ApexParser.DOT); + } else { + return this.getToken(ApexParser.DOT, i); + } + } + public soslId(): SoslIdContext[]; + public soslId(i: number): SoslIdContext | null; + public soslId(i?: number): SoslIdContext[] | SoslIdContext | null { + if (i === undefined) { + return this.getRuleContexts(SoslIdContext); + } + + return this.getRuleContext(i, SoslIdContext); + } + public override get ruleIndex(): number { + return ApexParser.RULE_soslId; + } + public override enterRule(listener: ApexParserListener): void { + if(listener.enterSoslId) { + listener.enterSoslId(this); + } + } + public override exitRule(listener: ApexParserListener): void { + if(listener.exitSoslId) { + listener.exitSoslId(this); + } + } + public override accept(visitor: ApexParserVisitor): Result | null { + if (visitor.visitSoslId) { + return visitor.visitSoslId(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class IdContext extends antlr.ParserRuleContext { + public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { + super(parent, invokingState); + } + public Identifier(): antlr.TerminalNode | null { + return this.getToken(ApexParser.Identifier, 0); + } + public AFTER(): antlr.TerminalNode | null { + return this.getToken(ApexParser.AFTER, 0); + } + public BEFORE(): antlr.TerminalNode | null { + return this.getToken(ApexParser.BEFORE, 0); + } + public GET(): antlr.TerminalNode | null { + return this.getToken(ApexParser.GET, 0); + } + public INHERITED(): antlr.TerminalNode | null { + return this.getToken(ApexParser.INHERITED, 0); + } + public INSTANCEOF(): antlr.TerminalNode | null { + return this.getToken(ApexParser.INSTANCEOF, 0); + } + public SET(): antlr.TerminalNode | null { + return this.getToken(ApexParser.SET, 0); + } + public SHARING(): antlr.TerminalNode | null { + return this.getToken(ApexParser.SHARING, 0); + } + public SWITCH(): antlr.TerminalNode | null { + return this.getToken(ApexParser.SWITCH, 0); + } + public TRANSIENT(): antlr.TerminalNode | null { + return this.getToken(ApexParser.TRANSIENT, 0); + } + public TRIGGER(): antlr.TerminalNode | null { + return this.getToken(ApexParser.TRIGGER, 0); + } + public WHEN(): antlr.TerminalNode | null { + return this.getToken(ApexParser.WHEN, 0); + } + public WITH(): antlr.TerminalNode | null { + return this.getToken(ApexParser.WITH, 0); + } + public WITHOUT(): antlr.TerminalNode | null { + return this.getToken(ApexParser.WITHOUT, 0); + } + public USER(): antlr.TerminalNode | null { + return this.getToken(ApexParser.USER, 0); + } + public SYSTEM(): antlr.TerminalNode | null { + return this.getToken(ApexParser.SYSTEM, 0); + } + public IntegralCurrencyLiteral(): antlr.TerminalNode | null { + return this.getToken(ApexParser.IntegralCurrencyLiteral, 0); + } + public SELECT(): antlr.TerminalNode | null { + return this.getToken(ApexParser.SELECT, 0); + } + public COUNT(): antlr.TerminalNode | null { + return this.getToken(ApexParser.COUNT, 0); + } + public FROM(): antlr.TerminalNode | null { + return this.getToken(ApexParser.FROM, 0); + } + public AS(): antlr.TerminalNode | null { + return this.getToken(ApexParser.AS, 0); + } + public USING(): antlr.TerminalNode | null { + return this.getToken(ApexParser.USING, 0); + } + public SCOPE(): antlr.TerminalNode | null { + return this.getToken(ApexParser.SCOPE, 0); + } + public WHERE(): antlr.TerminalNode | null { + return this.getToken(ApexParser.WHERE, 0); + } + public ORDER(): antlr.TerminalNode | null { + return this.getToken(ApexParser.ORDER, 0); + } + public BY(): antlr.TerminalNode | null { + return this.getToken(ApexParser.BY, 0); + } + public LIMIT(): antlr.TerminalNode | null { + return this.getToken(ApexParser.LIMIT, 0); + } + public SOQLAND(): antlr.TerminalNode | null { + return this.getToken(ApexParser.SOQLAND, 0); + } + public SOQLOR(): antlr.TerminalNode | null { + return this.getToken(ApexParser.SOQLOR, 0); + } + public NOT(): antlr.TerminalNode | null { + return this.getToken(ApexParser.NOT, 0); + } + public AVG(): antlr.TerminalNode | null { + return this.getToken(ApexParser.AVG, 0); + } + public COUNT_DISTINCT(): antlr.TerminalNode | null { + return this.getToken(ApexParser.COUNT_DISTINCT, 0); + } + public MIN(): antlr.TerminalNode | null { + return this.getToken(ApexParser.MIN, 0); + } + public MAX(): antlr.TerminalNode | null { + return this.getToken(ApexParser.MAX, 0); + } + public SUM(): antlr.TerminalNode | null { + return this.getToken(ApexParser.SUM, 0); + } + public TYPEOF(): antlr.TerminalNode | null { + return this.getToken(ApexParser.TYPEOF, 0); + } + public END(): antlr.TerminalNode | null { + return this.getToken(ApexParser.END, 0); + } + public THEN(): antlr.TerminalNode | null { + return this.getToken(ApexParser.THEN, 0); + } + public LIKE(): antlr.TerminalNode | null { + return this.getToken(ApexParser.LIKE, 0); + } + public IN(): antlr.TerminalNode | null { + return this.getToken(ApexParser.IN, 0); + } + public INCLUDES(): antlr.TerminalNode | null { + return this.getToken(ApexParser.INCLUDES, 0); + } + public EXCLUDES(): antlr.TerminalNode | null { + return this.getToken(ApexParser.EXCLUDES, 0); + } + public ASC(): antlr.TerminalNode | null { + return this.getToken(ApexParser.ASC, 0); + } + public DESC(): antlr.TerminalNode | null { + return this.getToken(ApexParser.DESC, 0); + } + public NULLS(): antlr.TerminalNode | null { + return this.getToken(ApexParser.NULLS, 0); + } + public FIRST(): antlr.TerminalNode | null { + return this.getToken(ApexParser.FIRST, 0); + } + public LAST(): antlr.TerminalNode | null { + return this.getToken(ApexParser.LAST, 0); + } + public GROUP(): antlr.TerminalNode | null { + return this.getToken(ApexParser.GROUP, 0); + } + public ALL(): antlr.TerminalNode | null { + return this.getToken(ApexParser.ALL, 0); + } + public ROWS(): antlr.TerminalNode | null { + return this.getToken(ApexParser.ROWS, 0); + } + public VIEW(): antlr.TerminalNode | null { + return this.getToken(ApexParser.VIEW, 0); + } + public HAVING(): antlr.TerminalNode | null { + return this.getToken(ApexParser.HAVING, 0); + } + public ROLLUP(): antlr.TerminalNode | null { + return this.getToken(ApexParser.ROLLUP, 0); + } + public TOLABEL(): antlr.TerminalNode | null { + return this.getToken(ApexParser.TOLABEL, 0); + } + public OFFSET(): antlr.TerminalNode | null { + return this.getToken(ApexParser.OFFSET, 0); + } + public DATA(): antlr.TerminalNode | null { + return this.getToken(ApexParser.DATA, 0); + } + public CATEGORY(): antlr.TerminalNode | null { + return this.getToken(ApexParser.CATEGORY, 0); + } + public AT(): antlr.TerminalNode | null { + return this.getToken(ApexParser.AT, 0); + } + public ABOVE(): antlr.TerminalNode | null { + return this.getToken(ApexParser.ABOVE, 0); + } + public BELOW(): antlr.TerminalNode | null { + return this.getToken(ApexParser.BELOW, 0); + } + public ABOVE_OR_BELOW(): antlr.TerminalNode | null { + return this.getToken(ApexParser.ABOVE_OR_BELOW, 0); + } + public SECURITY_ENFORCED(): antlr.TerminalNode | null { + return this.getToken(ApexParser.SECURITY_ENFORCED, 0); + } + public USER_MODE(): antlr.TerminalNode | null { + return this.getToken(ApexParser.USER_MODE, 0); + } + public SYSTEM_MODE(): antlr.TerminalNode | null { + return this.getToken(ApexParser.SYSTEM_MODE, 0); + } + public REFERENCE(): antlr.TerminalNode | null { + return this.getToken(ApexParser.REFERENCE, 0); + } + public CUBE(): antlr.TerminalNode | null { + return this.getToken(ApexParser.CUBE, 0); + } + public FORMAT(): antlr.TerminalNode | null { + return this.getToken(ApexParser.FORMAT, 0); + } + public TRACKING(): antlr.TerminalNode | null { + return this.getToken(ApexParser.TRACKING, 0); + } + public VIEWSTAT(): antlr.TerminalNode | null { + return this.getToken(ApexParser.VIEWSTAT, 0); + } + public STANDARD(): antlr.TerminalNode | null { + return this.getToken(ApexParser.STANDARD, 0); + } + public CUSTOM(): antlr.TerminalNode | null { + return this.getToken(ApexParser.CUSTOM, 0); + } + public DISTANCE(): antlr.TerminalNode | null { + return this.getToken(ApexParser.DISTANCE, 0); + } + public GEOLOCATION(): antlr.TerminalNode | null { + return this.getToken(ApexParser.GEOLOCATION, 0); + } + public CALENDAR_MONTH(): antlr.TerminalNode | null { + return this.getToken(ApexParser.CALENDAR_MONTH, 0); + } + public CALENDAR_QUARTER(): antlr.TerminalNode | null { + return this.getToken(ApexParser.CALENDAR_QUARTER, 0); + } + public CALENDAR_YEAR(): antlr.TerminalNode | null { + return this.getToken(ApexParser.CALENDAR_YEAR, 0); + } + public DAY_IN_MONTH(): antlr.TerminalNode | null { + return this.getToken(ApexParser.DAY_IN_MONTH, 0); + } + public DAY_IN_WEEK(): antlr.TerminalNode | null { + return this.getToken(ApexParser.DAY_IN_WEEK, 0); + } + public DAY_IN_YEAR(): antlr.TerminalNode | null { + return this.getToken(ApexParser.DAY_IN_YEAR, 0); + } + public DAY_ONLY(): antlr.TerminalNode | null { + return this.getToken(ApexParser.DAY_ONLY, 0); + } + public FISCAL_MONTH(): antlr.TerminalNode | null { + return this.getToken(ApexParser.FISCAL_MONTH, 0); + } + public FISCAL_QUARTER(): antlr.TerminalNode | null { + return this.getToken(ApexParser.FISCAL_QUARTER, 0); + } + public FISCAL_YEAR(): antlr.TerminalNode | null { + return this.getToken(ApexParser.FISCAL_YEAR, 0); + } + public HOUR_IN_DAY(): antlr.TerminalNode | null { + return this.getToken(ApexParser.HOUR_IN_DAY, 0); + } + public WEEK_IN_MONTH(): antlr.TerminalNode | null { + return this.getToken(ApexParser.WEEK_IN_MONTH, 0); + } + public WEEK_IN_YEAR(): antlr.TerminalNode | null { + return this.getToken(ApexParser.WEEK_IN_YEAR, 0); + } + public CONVERT_TIMEZONE(): antlr.TerminalNode | null { + return this.getToken(ApexParser.CONVERT_TIMEZONE, 0); + } + public YESTERDAY(): antlr.TerminalNode | null { + return this.getToken(ApexParser.YESTERDAY, 0); + } + public TODAY(): antlr.TerminalNode | null { + return this.getToken(ApexParser.TODAY, 0); + } + public TOMORROW(): antlr.TerminalNode | null { + return this.getToken(ApexParser.TOMORROW, 0); + } + public LAST_WEEK(): antlr.TerminalNode | null { + return this.getToken(ApexParser.LAST_WEEK, 0); + } + public THIS_WEEK(): antlr.TerminalNode | null { + return this.getToken(ApexParser.THIS_WEEK, 0); + } + public NEXT_WEEK(): antlr.TerminalNode | null { + return this.getToken(ApexParser.NEXT_WEEK, 0); + } + public LAST_MONTH(): antlr.TerminalNode | null { + return this.getToken(ApexParser.LAST_MONTH, 0); + } + public THIS_MONTH(): antlr.TerminalNode | null { + return this.getToken(ApexParser.THIS_MONTH, 0); + } + public NEXT_MONTH(): antlr.TerminalNode | null { + return this.getToken(ApexParser.NEXT_MONTH, 0); + } + public LAST_90_DAYS(): antlr.TerminalNode | null { + return this.getToken(ApexParser.LAST_90_DAYS, 0); + } + public NEXT_90_DAYS(): antlr.TerminalNode | null { + return this.getToken(ApexParser.NEXT_90_DAYS, 0); + } + public LAST_N_DAYS_N(): antlr.TerminalNode | null { + return this.getToken(ApexParser.LAST_N_DAYS_N, 0); + } + public NEXT_N_DAYS_N(): antlr.TerminalNode | null { + return this.getToken(ApexParser.NEXT_N_DAYS_N, 0); + } + public N_DAYS_AGO_N(): antlr.TerminalNode | null { + return this.getToken(ApexParser.N_DAYS_AGO_N, 0); + } + public NEXT_N_WEEKS_N(): antlr.TerminalNode | null { + return this.getToken(ApexParser.NEXT_N_WEEKS_N, 0); + } + public LAST_N_WEEKS_N(): antlr.TerminalNode | null { + return this.getToken(ApexParser.LAST_N_WEEKS_N, 0); + } + public N_WEEKS_AGO_N(): antlr.TerminalNode | null { + return this.getToken(ApexParser.N_WEEKS_AGO_N, 0); + } + public NEXT_N_MONTHS_N(): antlr.TerminalNode | null { + return this.getToken(ApexParser.NEXT_N_MONTHS_N, 0); + } + public LAST_N_MONTHS_N(): antlr.TerminalNode | null { + return this.getToken(ApexParser.LAST_N_MONTHS_N, 0); + } + public N_MONTHS_AGO_N(): antlr.TerminalNode | null { + return this.getToken(ApexParser.N_MONTHS_AGO_N, 0); + } + public THIS_QUARTER(): antlr.TerminalNode | null { + return this.getToken(ApexParser.THIS_QUARTER, 0); + } + public LAST_QUARTER(): antlr.TerminalNode | null { + return this.getToken(ApexParser.LAST_QUARTER, 0); + } + public NEXT_QUARTER(): antlr.TerminalNode | null { + return this.getToken(ApexParser.NEXT_QUARTER, 0); + } + public NEXT_N_QUARTERS_N(): antlr.TerminalNode | null { + return this.getToken(ApexParser.NEXT_N_QUARTERS_N, 0); + } + public LAST_N_QUARTERS_N(): antlr.TerminalNode | null { + return this.getToken(ApexParser.LAST_N_QUARTERS_N, 0); + } + public N_QUARTERS_AGO_N(): antlr.TerminalNode | null { + return this.getToken(ApexParser.N_QUARTERS_AGO_N, 0); + } + public THIS_YEAR(): antlr.TerminalNode | null { + return this.getToken(ApexParser.THIS_YEAR, 0); + } + public LAST_YEAR(): antlr.TerminalNode | null { + return this.getToken(ApexParser.LAST_YEAR, 0); + } + public NEXT_YEAR(): antlr.TerminalNode | null { + return this.getToken(ApexParser.NEXT_YEAR, 0); + } + public NEXT_N_YEARS_N(): antlr.TerminalNode | null { + return this.getToken(ApexParser.NEXT_N_YEARS_N, 0); + } + public LAST_N_YEARS_N(): antlr.TerminalNode | null { + return this.getToken(ApexParser.LAST_N_YEARS_N, 0); + } + public N_YEARS_AGO_N(): antlr.TerminalNode | null { + return this.getToken(ApexParser.N_YEARS_AGO_N, 0); + } + public THIS_FISCAL_QUARTER(): antlr.TerminalNode | null { + return this.getToken(ApexParser.THIS_FISCAL_QUARTER, 0); + } + public LAST_FISCAL_QUARTER(): antlr.TerminalNode | null { + return this.getToken(ApexParser.LAST_FISCAL_QUARTER, 0); + } + public NEXT_FISCAL_QUARTER(): antlr.TerminalNode | null { + return this.getToken(ApexParser.NEXT_FISCAL_QUARTER, 0); + } + public NEXT_N_FISCAL_QUARTERS_N(): antlr.TerminalNode | null { + return this.getToken(ApexParser.NEXT_N_FISCAL_QUARTERS_N, 0); + } + public LAST_N_FISCAL_QUARTERS_N(): antlr.TerminalNode | null { + return this.getToken(ApexParser.LAST_N_FISCAL_QUARTERS_N, 0); + } + public N_FISCAL_QUARTERS_AGO_N(): antlr.TerminalNode | null { + return this.getToken(ApexParser.N_FISCAL_QUARTERS_AGO_N, 0); + } + public THIS_FISCAL_YEAR(): antlr.TerminalNode | null { + return this.getToken(ApexParser.THIS_FISCAL_YEAR, 0); + } + public LAST_FISCAL_YEAR(): antlr.TerminalNode | null { + return this.getToken(ApexParser.LAST_FISCAL_YEAR, 0); + } + public NEXT_FISCAL_YEAR(): antlr.TerminalNode | null { + return this.getToken(ApexParser.NEXT_FISCAL_YEAR, 0); + } + public NEXT_N_FISCAL_YEARS_N(): antlr.TerminalNode | null { + return this.getToken(ApexParser.NEXT_N_FISCAL_YEARS_N, 0); + } + public LAST_N_FISCAL_YEARS_N(): antlr.TerminalNode | null { + return this.getToken(ApexParser.LAST_N_FISCAL_YEARS_N, 0); + } + public N_FISCAL_YEARS_AGO_N(): antlr.TerminalNode | null { + return this.getToken(ApexParser.N_FISCAL_YEARS_AGO_N, 0); + } + public FIND(): antlr.TerminalNode | null { + return this.getToken(ApexParser.FIND, 0); + } + public EMAIL(): antlr.TerminalNode | null { + return this.getToken(ApexParser.EMAIL, 0); + } + public NAME(): antlr.TerminalNode | null { + return this.getToken(ApexParser.NAME, 0); + } + public PHONE(): antlr.TerminalNode | null { + return this.getToken(ApexParser.PHONE, 0); + } + public SIDEBAR(): antlr.TerminalNode | null { + return this.getToken(ApexParser.SIDEBAR, 0); + } + public FIELDS(): antlr.TerminalNode | null { + return this.getToken(ApexParser.FIELDS, 0); + } + public METADATA(): antlr.TerminalNode | null { + return this.getToken(ApexParser.METADATA, 0); + } + public PRICEBOOKID(): antlr.TerminalNode | null { + return this.getToken(ApexParser.PRICEBOOKID, 0); + } + public NETWORK(): antlr.TerminalNode | null { + return this.getToken(ApexParser.NETWORK, 0); + } + public SNIPPET(): antlr.TerminalNode | null { + return this.getToken(ApexParser.SNIPPET, 0); + } + public TARGET_LENGTH(): antlr.TerminalNode | null { + return this.getToken(ApexParser.TARGET_LENGTH, 0); + } + public DIVISION(): antlr.TerminalNode | null { + return this.getToken(ApexParser.DIVISION, 0); + } + public RETURNING(): antlr.TerminalNode | null { + return this.getToken(ApexParser.RETURNING, 0); + } + public LISTVIEW(): antlr.TerminalNode | null { + return this.getToken(ApexParser.LISTVIEW, 0); + } + public override get ruleIndex(): number { + return ApexParser.RULE_id; + } + public override enterRule(listener: ApexParserListener): void { + if(listener.enterId) { + listener.enterId(this); + } + } + public override exitRule(listener: ApexParserListener): void { + if(listener.exitId) { + listener.exitId(this); + } + } + public override accept(visitor: ApexParserVisitor): Result | null { + if (visitor.visitId) { + return visitor.visitId(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class AnyIdContext extends antlr.ParserRuleContext { + public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { + super(parent, invokingState); + } + public Identifier(): antlr.TerminalNode | null { + return this.getToken(ApexParser.Identifier, 0); + } + public ABSTRACT(): antlr.TerminalNode | null { + return this.getToken(ApexParser.ABSTRACT, 0); + } + public AFTER(): antlr.TerminalNode | null { + return this.getToken(ApexParser.AFTER, 0); + } + public BEFORE(): antlr.TerminalNode | null { + return this.getToken(ApexParser.BEFORE, 0); + } + public BREAK(): antlr.TerminalNode | null { + return this.getToken(ApexParser.BREAK, 0); + } + public CATCH(): antlr.TerminalNode | null { + return this.getToken(ApexParser.CATCH, 0); + } + public CLASS(): antlr.TerminalNode | null { + return this.getToken(ApexParser.CLASS, 0); + } + public CONTINUE(): antlr.TerminalNode | null { + return this.getToken(ApexParser.CONTINUE, 0); + } + public DELETE(): antlr.TerminalNode | null { + return this.getToken(ApexParser.DELETE, 0); + } + public DO(): antlr.TerminalNode | null { + return this.getToken(ApexParser.DO, 0); + } + public ELSE(): antlr.TerminalNode | null { + return this.getToken(ApexParser.ELSE, 0); + } + public ENUM(): antlr.TerminalNode | null { + return this.getToken(ApexParser.ENUM, 0); + } + public EXTENDS(): antlr.TerminalNode | null { + return this.getToken(ApexParser.EXTENDS, 0); + } + public FINAL(): antlr.TerminalNode | null { + return this.getToken(ApexParser.FINAL, 0); + } + public FINALLY(): antlr.TerminalNode | null { + return this.getToken(ApexParser.FINALLY, 0); + } + public FOR(): antlr.TerminalNode | null { + return this.getToken(ApexParser.FOR, 0); + } + public GET(): antlr.TerminalNode | null { + return this.getToken(ApexParser.GET, 0); + } + public GLOBAL(): antlr.TerminalNode | null { + return this.getToken(ApexParser.GLOBAL, 0); + } + public IF(): antlr.TerminalNode | null { + return this.getToken(ApexParser.IF, 0); + } + public IMPLEMENTS(): antlr.TerminalNode | null { + return this.getToken(ApexParser.IMPLEMENTS, 0); + } + public INHERITED(): antlr.TerminalNode | null { + return this.getToken(ApexParser.INHERITED, 0); + } + public INSERT(): antlr.TerminalNode | null { + return this.getToken(ApexParser.INSERT, 0); + } + public INSTANCEOF(): antlr.TerminalNode | null { + return this.getToken(ApexParser.INSTANCEOF, 0); + } + public INTERFACE(): antlr.TerminalNode | null { + return this.getToken(ApexParser.INTERFACE, 0); + } + public LIST(): antlr.TerminalNode | null { + return this.getToken(ApexParser.LIST, 0); + } + public MAP(): antlr.TerminalNode | null { + return this.getToken(ApexParser.MAP, 0); + } + public MERGE(): antlr.TerminalNode | null { + return this.getToken(ApexParser.MERGE, 0); + } + public NEW(): antlr.TerminalNode | null { + return this.getToken(ApexParser.NEW, 0); + } + public NULL(): antlr.TerminalNode | null { + return this.getToken(ApexParser.NULL, 0); + } + public ON(): antlr.TerminalNode | null { + return this.getToken(ApexParser.ON, 0); + } + public OVERRIDE(): antlr.TerminalNode | null { + return this.getToken(ApexParser.OVERRIDE, 0); + } + public PRIVATE(): antlr.TerminalNode | null { + return this.getToken(ApexParser.PRIVATE, 0); + } + public PROTECTED(): antlr.TerminalNode | null { + return this.getToken(ApexParser.PROTECTED, 0); + } + public PUBLIC(): antlr.TerminalNode | null { + return this.getToken(ApexParser.PUBLIC, 0); + } + public RETURN(): antlr.TerminalNode | null { + return this.getToken(ApexParser.RETURN, 0); + } + public SET(): antlr.TerminalNode | null { + return this.getToken(ApexParser.SET, 0); + } + public SHARING(): antlr.TerminalNode | null { + return this.getToken(ApexParser.SHARING, 0); + } + public STATIC(): antlr.TerminalNode | null { + return this.getToken(ApexParser.STATIC, 0); + } + public SUPER(): antlr.TerminalNode | null { + return this.getToken(ApexParser.SUPER, 0); + } + public SWITCH(): antlr.TerminalNode | null { + return this.getToken(ApexParser.SWITCH, 0); + } + public TESTMETHOD(): antlr.TerminalNode | null { + return this.getToken(ApexParser.TESTMETHOD, 0); + } + public THIS(): antlr.TerminalNode | null { + return this.getToken(ApexParser.THIS, 0); + } + public THROW(): antlr.TerminalNode | null { + return this.getToken(ApexParser.THROW, 0); + } + public TRANSIENT(): antlr.TerminalNode | null { + return this.getToken(ApexParser.TRANSIENT, 0); + } + public TRIGGER(): antlr.TerminalNode | null { + return this.getToken(ApexParser.TRIGGER, 0); + } + public TRY(): antlr.TerminalNode | null { + return this.getToken(ApexParser.TRY, 0); + } + public UNDELETE(): antlr.TerminalNode | null { + return this.getToken(ApexParser.UNDELETE, 0); + } + public UPDATE(): antlr.TerminalNode | null { + return this.getToken(ApexParser.UPDATE, 0); + } + public UPSERT(): antlr.TerminalNode | null { + return this.getToken(ApexParser.UPSERT, 0); + } + public VIRTUAL(): antlr.TerminalNode | null { + return this.getToken(ApexParser.VIRTUAL, 0); + } + public WEBSERVICE(): antlr.TerminalNode | null { + return this.getToken(ApexParser.WEBSERVICE, 0); + } + public WHEN(): antlr.TerminalNode | null { + return this.getToken(ApexParser.WHEN, 0); + } + public WHILE(): antlr.TerminalNode | null { + return this.getToken(ApexParser.WHILE, 0); + } + public WITH(): antlr.TerminalNode | null { + return this.getToken(ApexParser.WITH, 0); + } + public WITHOUT(): antlr.TerminalNode | null { + return this.getToken(ApexParser.WITHOUT, 0); + } + public USER(): antlr.TerminalNode | null { + return this.getToken(ApexParser.USER, 0); + } + public SYSTEM(): antlr.TerminalNode | null { + return this.getToken(ApexParser.SYSTEM, 0); + } + public IntegralCurrencyLiteral(): antlr.TerminalNode | null { + return this.getToken(ApexParser.IntegralCurrencyLiteral, 0); + } + public SELECT(): antlr.TerminalNode | null { + return this.getToken(ApexParser.SELECT, 0); + } + public COUNT(): antlr.TerminalNode | null { + return this.getToken(ApexParser.COUNT, 0); + } + public FROM(): antlr.TerminalNode | null { + return this.getToken(ApexParser.FROM, 0); + } + public AS(): antlr.TerminalNode | null { + return this.getToken(ApexParser.AS, 0); + } + public USING(): antlr.TerminalNode | null { + return this.getToken(ApexParser.USING, 0); + } + public SCOPE(): antlr.TerminalNode | null { + return this.getToken(ApexParser.SCOPE, 0); + } + public WHERE(): antlr.TerminalNode | null { + return this.getToken(ApexParser.WHERE, 0); + } + public ORDER(): antlr.TerminalNode | null { + return this.getToken(ApexParser.ORDER, 0); + } + public BY(): antlr.TerminalNode | null { + return this.getToken(ApexParser.BY, 0); + } + public LIMIT(): antlr.TerminalNode | null { + return this.getToken(ApexParser.LIMIT, 0); + } + public SOQLAND(): antlr.TerminalNode | null { + return this.getToken(ApexParser.SOQLAND, 0); + } + public SOQLOR(): antlr.TerminalNode | null { + return this.getToken(ApexParser.SOQLOR, 0); + } + public NOT(): antlr.TerminalNode | null { + return this.getToken(ApexParser.NOT, 0); + } + public AVG(): antlr.TerminalNode | null { + return this.getToken(ApexParser.AVG, 0); + } + public COUNT_DISTINCT(): antlr.TerminalNode | null { + return this.getToken(ApexParser.COUNT_DISTINCT, 0); + } + public MIN(): antlr.TerminalNode | null { + return this.getToken(ApexParser.MIN, 0); + } + public MAX(): antlr.TerminalNode | null { + return this.getToken(ApexParser.MAX, 0); + } + public SUM(): antlr.TerminalNode | null { + return this.getToken(ApexParser.SUM, 0); + } + public TYPEOF(): antlr.TerminalNode | null { + return this.getToken(ApexParser.TYPEOF, 0); + } + public END(): antlr.TerminalNode | null { + return this.getToken(ApexParser.END, 0); + } + public THEN(): antlr.TerminalNode | null { + return this.getToken(ApexParser.THEN, 0); + } + public LIKE(): antlr.TerminalNode | null { + return this.getToken(ApexParser.LIKE, 0); + } + public IN(): antlr.TerminalNode | null { + return this.getToken(ApexParser.IN, 0); + } + public INCLUDES(): antlr.TerminalNode | null { + return this.getToken(ApexParser.INCLUDES, 0); + } + public EXCLUDES(): antlr.TerminalNode | null { + return this.getToken(ApexParser.EXCLUDES, 0); + } + public ASC(): antlr.TerminalNode | null { + return this.getToken(ApexParser.ASC, 0); + } + public DESC(): antlr.TerminalNode | null { + return this.getToken(ApexParser.DESC, 0); + } + public NULLS(): antlr.TerminalNode | null { + return this.getToken(ApexParser.NULLS, 0); + } + public FIRST(): antlr.TerminalNode | null { + return this.getToken(ApexParser.FIRST, 0); + } + public LAST(): antlr.TerminalNode | null { + return this.getToken(ApexParser.LAST, 0); + } + public GROUP(): antlr.TerminalNode | null { + return this.getToken(ApexParser.GROUP, 0); + } + public ALL(): antlr.TerminalNode | null { + return this.getToken(ApexParser.ALL, 0); + } + public ROWS(): antlr.TerminalNode | null { + return this.getToken(ApexParser.ROWS, 0); + } + public VIEW(): antlr.TerminalNode | null { + return this.getToken(ApexParser.VIEW, 0); + } + public HAVING(): antlr.TerminalNode | null { + return this.getToken(ApexParser.HAVING, 0); + } + public ROLLUP(): antlr.TerminalNode | null { + return this.getToken(ApexParser.ROLLUP, 0); + } + public TOLABEL(): antlr.TerminalNode | null { + return this.getToken(ApexParser.TOLABEL, 0); + } + public OFFSET(): antlr.TerminalNode | null { + return this.getToken(ApexParser.OFFSET, 0); + } + public DATA(): antlr.TerminalNode | null { + return this.getToken(ApexParser.DATA, 0); + } + public CATEGORY(): antlr.TerminalNode | null { + return this.getToken(ApexParser.CATEGORY, 0); + } + public AT(): antlr.TerminalNode | null { + return this.getToken(ApexParser.AT, 0); + } + public ABOVE(): antlr.TerminalNode | null { + return this.getToken(ApexParser.ABOVE, 0); + } + public BELOW(): antlr.TerminalNode | null { + return this.getToken(ApexParser.BELOW, 0); + } + public ABOVE_OR_BELOW(): antlr.TerminalNode | null { + return this.getToken(ApexParser.ABOVE_OR_BELOW, 0); + } + public SECURITY_ENFORCED(): antlr.TerminalNode | null { + return this.getToken(ApexParser.SECURITY_ENFORCED, 0); + } + public SYSTEM_MODE(): antlr.TerminalNode | null { + return this.getToken(ApexParser.SYSTEM_MODE, 0); + } + public USER_MODE(): antlr.TerminalNode | null { + return this.getToken(ApexParser.USER_MODE, 0); + } + public REFERENCE(): antlr.TerminalNode | null { + return this.getToken(ApexParser.REFERENCE, 0); + } + public CUBE(): antlr.TerminalNode | null { + return this.getToken(ApexParser.CUBE, 0); + } + public FORMAT(): antlr.TerminalNode | null { + return this.getToken(ApexParser.FORMAT, 0); + } + public TRACKING(): antlr.TerminalNode | null { + return this.getToken(ApexParser.TRACKING, 0); + } + public VIEWSTAT(): antlr.TerminalNode | null { + return this.getToken(ApexParser.VIEWSTAT, 0); + } + public STANDARD(): antlr.TerminalNode | null { + return this.getToken(ApexParser.STANDARD, 0); + } + public CUSTOM(): antlr.TerminalNode | null { + return this.getToken(ApexParser.CUSTOM, 0); + } + public DISTANCE(): antlr.TerminalNode | null { + return this.getToken(ApexParser.DISTANCE, 0); + } + public GEOLOCATION(): antlr.TerminalNode | null { + return this.getToken(ApexParser.GEOLOCATION, 0); + } + public CALENDAR_MONTH(): antlr.TerminalNode | null { + return this.getToken(ApexParser.CALENDAR_MONTH, 0); + } + public CALENDAR_QUARTER(): antlr.TerminalNode | null { + return this.getToken(ApexParser.CALENDAR_QUARTER, 0); + } + public CALENDAR_YEAR(): antlr.TerminalNode | null { + return this.getToken(ApexParser.CALENDAR_YEAR, 0); + } + public DAY_IN_MONTH(): antlr.TerminalNode | null { + return this.getToken(ApexParser.DAY_IN_MONTH, 0); + } + public DAY_IN_WEEK(): antlr.TerminalNode | null { + return this.getToken(ApexParser.DAY_IN_WEEK, 0); + } + public DAY_IN_YEAR(): antlr.TerminalNode | null { + return this.getToken(ApexParser.DAY_IN_YEAR, 0); + } + public DAY_ONLY(): antlr.TerminalNode | null { + return this.getToken(ApexParser.DAY_ONLY, 0); + } + public FISCAL_MONTH(): antlr.TerminalNode | null { + return this.getToken(ApexParser.FISCAL_MONTH, 0); + } + public FISCAL_QUARTER(): antlr.TerminalNode | null { + return this.getToken(ApexParser.FISCAL_QUARTER, 0); + } + public FISCAL_YEAR(): antlr.TerminalNode | null { + return this.getToken(ApexParser.FISCAL_YEAR, 0); + } + public HOUR_IN_DAY(): antlr.TerminalNode | null { + return this.getToken(ApexParser.HOUR_IN_DAY, 0); + } + public WEEK_IN_MONTH(): antlr.TerminalNode | null { + return this.getToken(ApexParser.WEEK_IN_MONTH, 0); + } + public WEEK_IN_YEAR(): antlr.TerminalNode | null { + return this.getToken(ApexParser.WEEK_IN_YEAR, 0); + } + public CONVERT_TIMEZONE(): antlr.TerminalNode | null { + return this.getToken(ApexParser.CONVERT_TIMEZONE, 0); + } + public YESTERDAY(): antlr.TerminalNode | null { + return this.getToken(ApexParser.YESTERDAY, 0); + } + public TODAY(): antlr.TerminalNode | null { + return this.getToken(ApexParser.TODAY, 0); + } + public TOMORROW(): antlr.TerminalNode | null { + return this.getToken(ApexParser.TOMORROW, 0); + } + public LAST_WEEK(): antlr.TerminalNode | null { + return this.getToken(ApexParser.LAST_WEEK, 0); + } + public THIS_WEEK(): antlr.TerminalNode | null { + return this.getToken(ApexParser.THIS_WEEK, 0); + } + public NEXT_WEEK(): antlr.TerminalNode | null { + return this.getToken(ApexParser.NEXT_WEEK, 0); + } + public LAST_MONTH(): antlr.TerminalNode | null { + return this.getToken(ApexParser.LAST_MONTH, 0); + } + public THIS_MONTH(): antlr.TerminalNode | null { + return this.getToken(ApexParser.THIS_MONTH, 0); + } + public NEXT_MONTH(): antlr.TerminalNode | null { + return this.getToken(ApexParser.NEXT_MONTH, 0); + } + public LAST_90_DAYS(): antlr.TerminalNode | null { + return this.getToken(ApexParser.LAST_90_DAYS, 0); + } + public NEXT_90_DAYS(): antlr.TerminalNode | null { + return this.getToken(ApexParser.NEXT_90_DAYS, 0); + } + public LAST_N_DAYS_N(): antlr.TerminalNode | null { + return this.getToken(ApexParser.LAST_N_DAYS_N, 0); + } + public NEXT_N_DAYS_N(): antlr.TerminalNode | null { + return this.getToken(ApexParser.NEXT_N_DAYS_N, 0); + } + public N_DAYS_AGO_N(): antlr.TerminalNode | null { + return this.getToken(ApexParser.N_DAYS_AGO_N, 0); + } + public NEXT_N_WEEKS_N(): antlr.TerminalNode | null { + return this.getToken(ApexParser.NEXT_N_WEEKS_N, 0); + } + public LAST_N_WEEKS_N(): antlr.TerminalNode | null { + return this.getToken(ApexParser.LAST_N_WEEKS_N, 0); + } + public N_WEEKS_AGO_N(): antlr.TerminalNode | null { + return this.getToken(ApexParser.N_WEEKS_AGO_N, 0); + } + public NEXT_N_MONTHS_N(): antlr.TerminalNode | null { + return this.getToken(ApexParser.NEXT_N_MONTHS_N, 0); + } + public LAST_N_MONTHS_N(): antlr.TerminalNode | null { + return this.getToken(ApexParser.LAST_N_MONTHS_N, 0); + } + public N_MONTHS_AGO_N(): antlr.TerminalNode | null { + return this.getToken(ApexParser.N_MONTHS_AGO_N, 0); + } + public THIS_QUARTER(): antlr.TerminalNode | null { + return this.getToken(ApexParser.THIS_QUARTER, 0); + } + public LAST_QUARTER(): antlr.TerminalNode | null { + return this.getToken(ApexParser.LAST_QUARTER, 0); + } + public NEXT_QUARTER(): antlr.TerminalNode | null { + return this.getToken(ApexParser.NEXT_QUARTER, 0); + } + public NEXT_N_QUARTERS_N(): antlr.TerminalNode | null { + return this.getToken(ApexParser.NEXT_N_QUARTERS_N, 0); + } + public LAST_N_QUARTERS_N(): antlr.TerminalNode | null { + return this.getToken(ApexParser.LAST_N_QUARTERS_N, 0); + } + public N_QUARTERS_AGO_N(): antlr.TerminalNode | null { + return this.getToken(ApexParser.N_QUARTERS_AGO_N, 0); + } + public THIS_YEAR(): antlr.TerminalNode | null { + return this.getToken(ApexParser.THIS_YEAR, 0); + } + public LAST_YEAR(): antlr.TerminalNode | null { + return this.getToken(ApexParser.LAST_YEAR, 0); + } + public NEXT_YEAR(): antlr.TerminalNode | null { + return this.getToken(ApexParser.NEXT_YEAR, 0); + } + public NEXT_N_YEARS_N(): antlr.TerminalNode | null { + return this.getToken(ApexParser.NEXT_N_YEARS_N, 0); + } + public LAST_N_YEARS_N(): antlr.TerminalNode | null { + return this.getToken(ApexParser.LAST_N_YEARS_N, 0); + } + public N_YEARS_AGO_N(): antlr.TerminalNode | null { + return this.getToken(ApexParser.N_YEARS_AGO_N, 0); + } + public THIS_FISCAL_QUARTER(): antlr.TerminalNode | null { + return this.getToken(ApexParser.THIS_FISCAL_QUARTER, 0); + } + public LAST_FISCAL_QUARTER(): antlr.TerminalNode | null { + return this.getToken(ApexParser.LAST_FISCAL_QUARTER, 0); + } + public NEXT_FISCAL_QUARTER(): antlr.TerminalNode | null { + return this.getToken(ApexParser.NEXT_FISCAL_QUARTER, 0); + } + public NEXT_N_FISCAL_QUARTERS_N(): antlr.TerminalNode | null { + return this.getToken(ApexParser.NEXT_N_FISCAL_QUARTERS_N, 0); + } + public LAST_N_FISCAL_QUARTERS_N(): antlr.TerminalNode | null { + return this.getToken(ApexParser.LAST_N_FISCAL_QUARTERS_N, 0); + } + public N_FISCAL_QUARTERS_AGO_N(): antlr.TerminalNode | null { + return this.getToken(ApexParser.N_FISCAL_QUARTERS_AGO_N, 0); + } + public THIS_FISCAL_YEAR(): antlr.TerminalNode | null { + return this.getToken(ApexParser.THIS_FISCAL_YEAR, 0); + } + public LAST_FISCAL_YEAR(): antlr.TerminalNode | null { + return this.getToken(ApexParser.LAST_FISCAL_YEAR, 0); + } + public NEXT_FISCAL_YEAR(): antlr.TerminalNode | null { + return this.getToken(ApexParser.NEXT_FISCAL_YEAR, 0); + } + public NEXT_N_FISCAL_YEARS_N(): antlr.TerminalNode | null { + return this.getToken(ApexParser.NEXT_N_FISCAL_YEARS_N, 0); + } + public LAST_N_FISCAL_YEARS_N(): antlr.TerminalNode | null { + return this.getToken(ApexParser.LAST_N_FISCAL_YEARS_N, 0); + } + public N_FISCAL_YEARS_AGO_N(): antlr.TerminalNode | null { + return this.getToken(ApexParser.N_FISCAL_YEARS_AGO_N, 0); + } + public FIND(): antlr.TerminalNode | null { + return this.getToken(ApexParser.FIND, 0); + } + public EMAIL(): antlr.TerminalNode | null { + return this.getToken(ApexParser.EMAIL, 0); + } + public NAME(): antlr.TerminalNode | null { + return this.getToken(ApexParser.NAME, 0); + } + public PHONE(): antlr.TerminalNode | null { + return this.getToken(ApexParser.PHONE, 0); + } + public SIDEBAR(): antlr.TerminalNode | null { + return this.getToken(ApexParser.SIDEBAR, 0); + } + public FIELDS(): antlr.TerminalNode | null { + return this.getToken(ApexParser.FIELDS, 0); + } + public METADATA(): antlr.TerminalNode | null { + return this.getToken(ApexParser.METADATA, 0); + } + public PRICEBOOKID(): antlr.TerminalNode | null { + return this.getToken(ApexParser.PRICEBOOKID, 0); + } + public NETWORK(): antlr.TerminalNode | null { + return this.getToken(ApexParser.NETWORK, 0); + } + public SNIPPET(): antlr.TerminalNode | null { + return this.getToken(ApexParser.SNIPPET, 0); + } + public TARGET_LENGTH(): antlr.TerminalNode | null { + return this.getToken(ApexParser.TARGET_LENGTH, 0); + } + public DIVISION(): antlr.TerminalNode | null { + return this.getToken(ApexParser.DIVISION, 0); + } + public RETURNING(): antlr.TerminalNode | null { + return this.getToken(ApexParser.RETURNING, 0); + } + public LISTVIEW(): antlr.TerminalNode | null { + return this.getToken(ApexParser.LISTVIEW, 0); + } + public override get ruleIndex(): number { + return ApexParser.RULE_anyId; + } + public override enterRule(listener: ApexParserListener): void { + if(listener.enterAnyId) { + listener.enterAnyId(this); + } + } + public override exitRule(listener: ApexParserListener): void { + if(listener.exitAnyId) { + listener.exitAnyId(this); + } + } + public override accept(visitor: ApexParserVisitor): Result | null { + if (visitor.visitAnyId) { + return visitor.visitAnyId(this); + } else { + return visitor.visitChildren(this); + } + } +} diff --git a/packages/apex/src/grammar/ApexParserListener.ts b/packages/apex/src/grammar/ApexParserListener.ts new file mode 100644 index 00000000..2f7e2f9e --- /dev/null +++ b/packages/apex/src/grammar/ApexParserListener.ts @@ -0,0 +1,1997 @@ +// Generated from ./grammar/ApexParser.g4 by ANTLR 4.13.1 + +import { ErrorNode, ParseTreeListener, ParserRuleContext, TerminalNode } from "antlr4ng"; + + +import { TriggerUnitContext } from "./ApexParser.js"; +import { TriggerCaseContext } from "./ApexParser.js"; +import { CompilationUnitContext } from "./ApexParser.js"; +import { TypeDeclarationContext } from "./ApexParser.js"; +import { ClassDeclarationContext } from "./ApexParser.js"; +import { EnumDeclarationContext } from "./ApexParser.js"; +import { EnumConstantsContext } from "./ApexParser.js"; +import { InterfaceDeclarationContext } from "./ApexParser.js"; +import { TypeListContext } from "./ApexParser.js"; +import { ClassBodyContext } from "./ApexParser.js"; +import { InterfaceBodyContext } from "./ApexParser.js"; +import { ClassBodyDeclarationContext } from "./ApexParser.js"; +import { ModifierContext } from "./ApexParser.js"; +import { MemberDeclarationContext } from "./ApexParser.js"; +import { MethodDeclarationContext } from "./ApexParser.js"; +import { ConstructorDeclarationContext } from "./ApexParser.js"; +import { FieldDeclarationContext } from "./ApexParser.js"; +import { PropertyDeclarationContext } from "./ApexParser.js"; +import { InterfaceMethodDeclarationContext } from "./ApexParser.js"; +import { VariableDeclaratorsContext } from "./ApexParser.js"; +import { VariableDeclaratorContext } from "./ApexParser.js"; +import { ArrayInitializerContext } from "./ApexParser.js"; +import { TypeRefContext } from "./ApexParser.js"; +import { ArraySubscriptsContext } from "./ApexParser.js"; +import { TypeNameContext } from "./ApexParser.js"; +import { TypeArgumentsContext } from "./ApexParser.js"; +import { FormalParametersContext } from "./ApexParser.js"; +import { FormalParameterListContext } from "./ApexParser.js"; +import { FormalParameterContext } from "./ApexParser.js"; +import { QualifiedNameContext } from "./ApexParser.js"; +import { LiteralContext } from "./ApexParser.js"; +import { AnnotationContext } from "./ApexParser.js"; +import { ElementValuePairsContext } from "./ApexParser.js"; +import { ElementValuePairContext } from "./ApexParser.js"; +import { ElementValueContext } from "./ApexParser.js"; +import { ElementValueArrayInitializerContext } from "./ApexParser.js"; +import { BlockContext } from "./ApexParser.js"; +import { LocalVariableDeclarationStatementContext } from "./ApexParser.js"; +import { LocalVariableDeclarationContext } from "./ApexParser.js"; +import { StatementContext } from "./ApexParser.js"; +import { IfStatementContext } from "./ApexParser.js"; +import { SwitchStatementContext } from "./ApexParser.js"; +import { WhenControlContext } from "./ApexParser.js"; +import { WhenValueContext } from "./ApexParser.js"; +import { WhenLiteralContext } from "./ApexParser.js"; +import { ForStatementContext } from "./ApexParser.js"; +import { WhileStatementContext } from "./ApexParser.js"; +import { DoWhileStatementContext } from "./ApexParser.js"; +import { TryStatementContext } from "./ApexParser.js"; +import { ReturnStatementContext } from "./ApexParser.js"; +import { ThrowStatementContext } from "./ApexParser.js"; +import { BreakStatementContext } from "./ApexParser.js"; +import { ContinueStatementContext } from "./ApexParser.js"; +import { AccessLevelContext } from "./ApexParser.js"; +import { InsertStatementContext } from "./ApexParser.js"; +import { UpdateStatementContext } from "./ApexParser.js"; +import { DeleteStatementContext } from "./ApexParser.js"; +import { UndeleteStatementContext } from "./ApexParser.js"; +import { UpsertStatementContext } from "./ApexParser.js"; +import { MergeStatementContext } from "./ApexParser.js"; +import { RunAsStatementContext } from "./ApexParser.js"; +import { ExpressionStatementContext } from "./ApexParser.js"; +import { PropertyBlockContext } from "./ApexParser.js"; +import { GetterContext } from "./ApexParser.js"; +import { SetterContext } from "./ApexParser.js"; +import { CatchClauseContext } from "./ApexParser.js"; +import { FinallyBlockContext } from "./ApexParser.js"; +import { ForControlContext } from "./ApexParser.js"; +import { ForInitContext } from "./ApexParser.js"; +import { EnhancedForControlContext } from "./ApexParser.js"; +import { ForUpdateContext } from "./ApexParser.js"; +import { ParExpressionContext } from "./ApexParser.js"; +import { ExpressionListContext } from "./ApexParser.js"; +import { PrimaryExpressionContext } from "./ApexParser.js"; +import { Arth1ExpressionContext } from "./ApexParser.js"; +import { DotExpressionContext } from "./ApexParser.js"; +import { BitOrExpressionContext } from "./ApexParser.js"; +import { ArrayExpressionContext } from "./ApexParser.js"; +import { NewExpressionContext } from "./ApexParser.js"; +import { AssignExpressionContext } from "./ApexParser.js"; +import { MethodCallExpressionContext } from "./ApexParser.js"; +import { BitNotExpressionContext } from "./ApexParser.js"; +import { Arth2ExpressionContext } from "./ApexParser.js"; +import { LogAndExpressionContext } from "./ApexParser.js"; +import { CoalescingExpressionContext } from "./ApexParser.js"; +import { CastExpressionContext } from "./ApexParser.js"; +import { BitAndExpressionContext } from "./ApexParser.js"; +import { CmpExpressionContext } from "./ApexParser.js"; +import { BitExpressionContext } from "./ApexParser.js"; +import { LogOrExpressionContext } from "./ApexParser.js"; +import { CondExpressionContext } from "./ApexParser.js"; +import { EqualityExpressionContext } from "./ApexParser.js"; +import { PostOpExpressionContext } from "./ApexParser.js"; +import { NegExpressionContext } from "./ApexParser.js"; +import { PreOpExpressionContext } from "./ApexParser.js"; +import { SubExpressionContext } from "./ApexParser.js"; +import { InstanceOfExpressionContext } from "./ApexParser.js"; +import { ThisPrimaryContext } from "./ApexParser.js"; +import { SuperPrimaryContext } from "./ApexParser.js"; +import { LiteralPrimaryContext } from "./ApexParser.js"; +import { TypeRefPrimaryContext } from "./ApexParser.js"; +import { VoidPrimaryContext } from "./ApexParser.js"; +import { IdPrimaryContext } from "./ApexParser.js"; +import { SoqlPrimaryContext } from "./ApexParser.js"; +import { SoslPrimaryContext } from "./ApexParser.js"; +import { MethodCallContext } from "./ApexParser.js"; +import { DotMethodCallContext } from "./ApexParser.js"; +import { CreatorContext } from "./ApexParser.js"; +import { CreatedNameContext } from "./ApexParser.js"; +import { IdCreatedNamePairContext } from "./ApexParser.js"; +import { NoRestContext } from "./ApexParser.js"; +import { ClassCreatorRestContext } from "./ApexParser.js"; +import { ArrayCreatorRestContext } from "./ApexParser.js"; +import { MapCreatorRestContext } from "./ApexParser.js"; +import { MapCreatorRestPairContext } from "./ApexParser.js"; +import { SetCreatorRestContext } from "./ApexParser.js"; +import { ArgumentsContext } from "./ApexParser.js"; +import { SoqlLiteralContext } from "./ApexParser.js"; +import { QueryContext } from "./ApexParser.js"; +import { SubQueryContext } from "./ApexParser.js"; +import { SelectListContext } from "./ApexParser.js"; +import { SelectEntryContext } from "./ApexParser.js"; +import { FieldNameContext } from "./ApexParser.js"; +import { FromNameListContext } from "./ApexParser.js"; +import { SubFieldListContext } from "./ApexParser.js"; +import { SubFieldEntryContext } from "./ApexParser.js"; +import { SoqlFieldsParameterContext } from "./ApexParser.js"; +import { SoqlFunctionContext } from "./ApexParser.js"; +import { DateFieldNameContext } from "./ApexParser.js"; +import { LocationValueContext } from "./ApexParser.js"; +import { CoordinateValueContext } from "./ApexParser.js"; +import { TypeOfContext } from "./ApexParser.js"; +import { WhenClauseContext } from "./ApexParser.js"; +import { ElseClauseContext } from "./ApexParser.js"; +import { FieldNameListContext } from "./ApexParser.js"; +import { UsingScopeContext } from "./ApexParser.js"; +import { WhereClauseContext } from "./ApexParser.js"; +import { LogicalExpressionContext } from "./ApexParser.js"; +import { ConditionalExpressionContext } from "./ApexParser.js"; +import { FieldExpressionContext } from "./ApexParser.js"; +import { ComparisonOperatorContext } from "./ApexParser.js"; +import { ValueContext } from "./ApexParser.js"; +import { ValueListContext } from "./ApexParser.js"; +import { SignedNumberContext } from "./ApexParser.js"; +import { WithClauseContext } from "./ApexParser.js"; +import { FilteringExpressionContext } from "./ApexParser.js"; +import { DataCategorySelectionContext } from "./ApexParser.js"; +import { DataCategoryNameContext } from "./ApexParser.js"; +import { FilteringSelectorContext } from "./ApexParser.js"; +import { GroupByClauseContext } from "./ApexParser.js"; +import { OrderByClauseContext } from "./ApexParser.js"; +import { FieldOrderListContext } from "./ApexParser.js"; +import { FieldOrderContext } from "./ApexParser.js"; +import { LimitClauseContext } from "./ApexParser.js"; +import { OffsetClauseContext } from "./ApexParser.js"; +import { AllRowsClauseContext } from "./ApexParser.js"; +import { ForClausesContext } from "./ApexParser.js"; +import { BoundExpressionContext } from "./ApexParser.js"; +import { DateFormulaContext } from "./ApexParser.js"; +import { SignedIntegerContext } from "./ApexParser.js"; +import { SoqlIdContext } from "./ApexParser.js"; +import { SoslLiteralContext } from "./ApexParser.js"; +import { SoslLiteralAltContext } from "./ApexParser.js"; +import { SoslClausesContext } from "./ApexParser.js"; +import { SearchGroupContext } from "./ApexParser.js"; +import { FieldSpecListContext } from "./ApexParser.js"; +import { FieldSpecContext } from "./ApexParser.js"; +import { FieldListContext } from "./ApexParser.js"; +import { UpdateListContext } from "./ApexParser.js"; +import { UpdateTypeContext } from "./ApexParser.js"; +import { NetworkListContext } from "./ApexParser.js"; +import { SoslIdContext } from "./ApexParser.js"; +import { IdContext } from "./ApexParser.js"; +import { AnyIdContext } from "./ApexParser.js"; + + +/** + * This interface defines a complete listener for a parse tree produced by + * `ApexParser`. + */ +export class ApexParserListener implements ParseTreeListener { + /** + * Enter a parse tree produced by `ApexParser.triggerUnit`. + * @param ctx the parse tree + */ + enterTriggerUnit? (ctx: TriggerUnitContext): void; + /** + * Exit a parse tree produced by `ApexParser.triggerUnit`. + * @param ctx the parse tree + */ + exitTriggerUnit? (ctx: TriggerUnitContext): void; + /** + * Enter a parse tree produced by `ApexParser.triggerCase`. + * @param ctx the parse tree + */ + enterTriggerCase? (ctx: TriggerCaseContext): void; + /** + * Exit a parse tree produced by `ApexParser.triggerCase`. + * @param ctx the parse tree + */ + exitTriggerCase? (ctx: TriggerCaseContext): void; + /** + * Enter a parse tree produced by `ApexParser.compilationUnit`. + * @param ctx the parse tree + */ + enterCompilationUnit? (ctx: CompilationUnitContext): void; + /** + * Exit a parse tree produced by `ApexParser.compilationUnit`. + * @param ctx the parse tree + */ + exitCompilationUnit? (ctx: CompilationUnitContext): void; + /** + * Enter a parse tree produced by `ApexParser.typeDeclaration`. + * @param ctx the parse tree + */ + enterTypeDeclaration? (ctx: TypeDeclarationContext): void; + /** + * Exit a parse tree produced by `ApexParser.typeDeclaration`. + * @param ctx the parse tree + */ + exitTypeDeclaration? (ctx: TypeDeclarationContext): void; + /** + * Enter a parse tree produced by `ApexParser.classDeclaration`. + * @param ctx the parse tree + */ + enterClassDeclaration? (ctx: ClassDeclarationContext): void; + /** + * Exit a parse tree produced by `ApexParser.classDeclaration`. + * @param ctx the parse tree + */ + exitClassDeclaration? (ctx: ClassDeclarationContext): void; + /** + * Enter a parse tree produced by `ApexParser.enumDeclaration`. + * @param ctx the parse tree + */ + enterEnumDeclaration? (ctx: EnumDeclarationContext): void; + /** + * Exit a parse tree produced by `ApexParser.enumDeclaration`. + * @param ctx the parse tree + */ + exitEnumDeclaration? (ctx: EnumDeclarationContext): void; + /** + * Enter a parse tree produced by `ApexParser.enumConstants`. + * @param ctx the parse tree + */ + enterEnumConstants? (ctx: EnumConstantsContext): void; + /** + * Exit a parse tree produced by `ApexParser.enumConstants`. + * @param ctx the parse tree + */ + exitEnumConstants? (ctx: EnumConstantsContext): void; + /** + * Enter a parse tree produced by `ApexParser.interfaceDeclaration`. + * @param ctx the parse tree + */ + enterInterfaceDeclaration? (ctx: InterfaceDeclarationContext): void; + /** + * Exit a parse tree produced by `ApexParser.interfaceDeclaration`. + * @param ctx the parse tree + */ + exitInterfaceDeclaration? (ctx: InterfaceDeclarationContext): void; + /** + * Enter a parse tree produced by `ApexParser.typeList`. + * @param ctx the parse tree + */ + enterTypeList? (ctx: TypeListContext): void; + /** + * Exit a parse tree produced by `ApexParser.typeList`. + * @param ctx the parse tree + */ + exitTypeList? (ctx: TypeListContext): void; + /** + * Enter a parse tree produced by `ApexParser.classBody`. + * @param ctx the parse tree + */ + enterClassBody? (ctx: ClassBodyContext): void; + /** + * Exit a parse tree produced by `ApexParser.classBody`. + * @param ctx the parse tree + */ + exitClassBody? (ctx: ClassBodyContext): void; + /** + * Enter a parse tree produced by `ApexParser.interfaceBody`. + * @param ctx the parse tree + */ + enterInterfaceBody? (ctx: InterfaceBodyContext): void; + /** + * Exit a parse tree produced by `ApexParser.interfaceBody`. + * @param ctx the parse tree + */ + exitInterfaceBody? (ctx: InterfaceBodyContext): void; + /** + * Enter a parse tree produced by `ApexParser.classBodyDeclaration`. + * @param ctx the parse tree + */ + enterClassBodyDeclaration? (ctx: ClassBodyDeclarationContext): void; + /** + * Exit a parse tree produced by `ApexParser.classBodyDeclaration`. + * @param ctx the parse tree + */ + exitClassBodyDeclaration? (ctx: ClassBodyDeclarationContext): void; + /** + * Enter a parse tree produced by `ApexParser.modifier`. + * @param ctx the parse tree + */ + enterModifier? (ctx: ModifierContext): void; + /** + * Exit a parse tree produced by `ApexParser.modifier`. + * @param ctx the parse tree + */ + exitModifier? (ctx: ModifierContext): void; + /** + * Enter a parse tree produced by `ApexParser.memberDeclaration`. + * @param ctx the parse tree + */ + enterMemberDeclaration? (ctx: MemberDeclarationContext): void; + /** + * Exit a parse tree produced by `ApexParser.memberDeclaration`. + * @param ctx the parse tree + */ + exitMemberDeclaration? (ctx: MemberDeclarationContext): void; + /** + * Enter a parse tree produced by `ApexParser.methodDeclaration`. + * @param ctx the parse tree + */ + enterMethodDeclaration? (ctx: MethodDeclarationContext): void; + /** + * Exit a parse tree produced by `ApexParser.methodDeclaration`. + * @param ctx the parse tree + */ + exitMethodDeclaration? (ctx: MethodDeclarationContext): void; + /** + * Enter a parse tree produced by `ApexParser.constructorDeclaration`. + * @param ctx the parse tree + */ + enterConstructorDeclaration? (ctx: ConstructorDeclarationContext): void; + /** + * Exit a parse tree produced by `ApexParser.constructorDeclaration`. + * @param ctx the parse tree + */ + exitConstructorDeclaration? (ctx: ConstructorDeclarationContext): void; + /** + * Enter a parse tree produced by `ApexParser.fieldDeclaration`. + * @param ctx the parse tree + */ + enterFieldDeclaration? (ctx: FieldDeclarationContext): void; + /** + * Exit a parse tree produced by `ApexParser.fieldDeclaration`. + * @param ctx the parse tree + */ + exitFieldDeclaration? (ctx: FieldDeclarationContext): void; + /** + * Enter a parse tree produced by `ApexParser.propertyDeclaration`. + * @param ctx the parse tree + */ + enterPropertyDeclaration? (ctx: PropertyDeclarationContext): void; + /** + * Exit a parse tree produced by `ApexParser.propertyDeclaration`. + * @param ctx the parse tree + */ + exitPropertyDeclaration? (ctx: PropertyDeclarationContext): void; + /** + * Enter a parse tree produced by `ApexParser.interfaceMethodDeclaration`. + * @param ctx the parse tree + */ + enterInterfaceMethodDeclaration? (ctx: InterfaceMethodDeclarationContext): void; + /** + * Exit a parse tree produced by `ApexParser.interfaceMethodDeclaration`. + * @param ctx the parse tree + */ + exitInterfaceMethodDeclaration? (ctx: InterfaceMethodDeclarationContext): void; + /** + * Enter a parse tree produced by `ApexParser.variableDeclarators`. + * @param ctx the parse tree + */ + enterVariableDeclarators? (ctx: VariableDeclaratorsContext): void; + /** + * Exit a parse tree produced by `ApexParser.variableDeclarators`. + * @param ctx the parse tree + */ + exitVariableDeclarators? (ctx: VariableDeclaratorsContext): void; + /** + * Enter a parse tree produced by `ApexParser.variableDeclarator`. + * @param ctx the parse tree + */ + enterVariableDeclarator? (ctx: VariableDeclaratorContext): void; + /** + * Exit a parse tree produced by `ApexParser.variableDeclarator`. + * @param ctx the parse tree + */ + exitVariableDeclarator? (ctx: VariableDeclaratorContext): void; + /** + * Enter a parse tree produced by `ApexParser.arrayInitializer`. + * @param ctx the parse tree + */ + enterArrayInitializer? (ctx: ArrayInitializerContext): void; + /** + * Exit a parse tree produced by `ApexParser.arrayInitializer`. + * @param ctx the parse tree + */ + exitArrayInitializer? (ctx: ArrayInitializerContext): void; + /** + * Enter a parse tree produced by `ApexParser.typeRef`. + * @param ctx the parse tree + */ + enterTypeRef? (ctx: TypeRefContext): void; + /** + * Exit a parse tree produced by `ApexParser.typeRef`. + * @param ctx the parse tree + */ + exitTypeRef? (ctx: TypeRefContext): void; + /** + * Enter a parse tree produced by `ApexParser.arraySubscripts`. + * @param ctx the parse tree + */ + enterArraySubscripts? (ctx: ArraySubscriptsContext): void; + /** + * Exit a parse tree produced by `ApexParser.arraySubscripts`. + * @param ctx the parse tree + */ + exitArraySubscripts? (ctx: ArraySubscriptsContext): void; + /** + * Enter a parse tree produced by `ApexParser.typeName`. + * @param ctx the parse tree + */ + enterTypeName? (ctx: TypeNameContext): void; + /** + * Exit a parse tree produced by `ApexParser.typeName`. + * @param ctx the parse tree + */ + exitTypeName? (ctx: TypeNameContext): void; + /** + * Enter a parse tree produced by `ApexParser.typeArguments`. + * @param ctx the parse tree + */ + enterTypeArguments? (ctx: TypeArgumentsContext): void; + /** + * Exit a parse tree produced by `ApexParser.typeArguments`. + * @param ctx the parse tree + */ + exitTypeArguments? (ctx: TypeArgumentsContext): void; + /** + * Enter a parse tree produced by `ApexParser.formalParameters`. + * @param ctx the parse tree + */ + enterFormalParameters? (ctx: FormalParametersContext): void; + /** + * Exit a parse tree produced by `ApexParser.formalParameters`. + * @param ctx the parse tree + */ + exitFormalParameters? (ctx: FormalParametersContext): void; + /** + * Enter a parse tree produced by `ApexParser.formalParameterList`. + * @param ctx the parse tree + */ + enterFormalParameterList? (ctx: FormalParameterListContext): void; + /** + * Exit a parse tree produced by `ApexParser.formalParameterList`. + * @param ctx the parse tree + */ + exitFormalParameterList? (ctx: FormalParameterListContext): void; + /** + * Enter a parse tree produced by `ApexParser.formalParameter`. + * @param ctx the parse tree + */ + enterFormalParameter? (ctx: FormalParameterContext): void; + /** + * Exit a parse tree produced by `ApexParser.formalParameter`. + * @param ctx the parse tree + */ + exitFormalParameter? (ctx: FormalParameterContext): void; + /** + * Enter a parse tree produced by `ApexParser.qualifiedName`. + * @param ctx the parse tree + */ + enterQualifiedName? (ctx: QualifiedNameContext): void; + /** + * Exit a parse tree produced by `ApexParser.qualifiedName`. + * @param ctx the parse tree + */ + exitQualifiedName? (ctx: QualifiedNameContext): void; + /** + * Enter a parse tree produced by `ApexParser.literal`. + * @param ctx the parse tree + */ + enterLiteral? (ctx: LiteralContext): void; + /** + * Exit a parse tree produced by `ApexParser.literal`. + * @param ctx the parse tree + */ + exitLiteral? (ctx: LiteralContext): void; + /** + * Enter a parse tree produced by `ApexParser.annotation`. + * @param ctx the parse tree + */ + enterAnnotation? (ctx: AnnotationContext): void; + /** + * Exit a parse tree produced by `ApexParser.annotation`. + * @param ctx the parse tree + */ + exitAnnotation? (ctx: AnnotationContext): void; + /** + * Enter a parse tree produced by `ApexParser.elementValuePairs`. + * @param ctx the parse tree + */ + enterElementValuePairs? (ctx: ElementValuePairsContext): void; + /** + * Exit a parse tree produced by `ApexParser.elementValuePairs`. + * @param ctx the parse tree + */ + exitElementValuePairs? (ctx: ElementValuePairsContext): void; + /** + * Enter a parse tree produced by `ApexParser.elementValuePair`. + * @param ctx the parse tree + */ + enterElementValuePair? (ctx: ElementValuePairContext): void; + /** + * Exit a parse tree produced by `ApexParser.elementValuePair`. + * @param ctx the parse tree + */ + exitElementValuePair? (ctx: ElementValuePairContext): void; + /** + * Enter a parse tree produced by `ApexParser.elementValue`. + * @param ctx the parse tree + */ + enterElementValue? (ctx: ElementValueContext): void; + /** + * Exit a parse tree produced by `ApexParser.elementValue`. + * @param ctx the parse tree + */ + exitElementValue? (ctx: ElementValueContext): void; + /** + * Enter a parse tree produced by `ApexParser.elementValueArrayInitializer`. + * @param ctx the parse tree + */ + enterElementValueArrayInitializer? (ctx: ElementValueArrayInitializerContext): void; + /** + * Exit a parse tree produced by `ApexParser.elementValueArrayInitializer`. + * @param ctx the parse tree + */ + exitElementValueArrayInitializer? (ctx: ElementValueArrayInitializerContext): void; + /** + * Enter a parse tree produced by `ApexParser.block`. + * @param ctx the parse tree + */ + enterBlock? (ctx: BlockContext): void; + /** + * Exit a parse tree produced by `ApexParser.block`. + * @param ctx the parse tree + */ + exitBlock? (ctx: BlockContext): void; + /** + * Enter a parse tree produced by `ApexParser.localVariableDeclarationStatement`. + * @param ctx the parse tree + */ + enterLocalVariableDeclarationStatement? (ctx: LocalVariableDeclarationStatementContext): void; + /** + * Exit a parse tree produced by `ApexParser.localVariableDeclarationStatement`. + * @param ctx the parse tree + */ + exitLocalVariableDeclarationStatement? (ctx: LocalVariableDeclarationStatementContext): void; + /** + * Enter a parse tree produced by `ApexParser.localVariableDeclaration`. + * @param ctx the parse tree + */ + enterLocalVariableDeclaration? (ctx: LocalVariableDeclarationContext): void; + /** + * Exit a parse tree produced by `ApexParser.localVariableDeclaration`. + * @param ctx the parse tree + */ + exitLocalVariableDeclaration? (ctx: LocalVariableDeclarationContext): void; + /** + * Enter a parse tree produced by `ApexParser.statement`. + * @param ctx the parse tree + */ + enterStatement? (ctx: StatementContext): void; + /** + * Exit a parse tree produced by `ApexParser.statement`. + * @param ctx the parse tree + */ + exitStatement? (ctx: StatementContext): void; + /** + * Enter a parse tree produced by `ApexParser.ifStatement`. + * @param ctx the parse tree + */ + enterIfStatement? (ctx: IfStatementContext): void; + /** + * Exit a parse tree produced by `ApexParser.ifStatement`. + * @param ctx the parse tree + */ + exitIfStatement? (ctx: IfStatementContext): void; + /** + * Enter a parse tree produced by `ApexParser.switchStatement`. + * @param ctx the parse tree + */ + enterSwitchStatement? (ctx: SwitchStatementContext): void; + /** + * Exit a parse tree produced by `ApexParser.switchStatement`. + * @param ctx the parse tree + */ + exitSwitchStatement? (ctx: SwitchStatementContext): void; + /** + * Enter a parse tree produced by `ApexParser.whenControl`. + * @param ctx the parse tree + */ + enterWhenControl? (ctx: WhenControlContext): void; + /** + * Exit a parse tree produced by `ApexParser.whenControl`. + * @param ctx the parse tree + */ + exitWhenControl? (ctx: WhenControlContext): void; + /** + * Enter a parse tree produced by `ApexParser.whenValue`. + * @param ctx the parse tree + */ + enterWhenValue? (ctx: WhenValueContext): void; + /** + * Exit a parse tree produced by `ApexParser.whenValue`. + * @param ctx the parse tree + */ + exitWhenValue? (ctx: WhenValueContext): void; + /** + * Enter a parse tree produced by `ApexParser.whenLiteral`. + * @param ctx the parse tree + */ + enterWhenLiteral? (ctx: WhenLiteralContext): void; + /** + * Exit a parse tree produced by `ApexParser.whenLiteral`. + * @param ctx the parse tree + */ + exitWhenLiteral? (ctx: WhenLiteralContext): void; + /** + * Enter a parse tree produced by `ApexParser.forStatement`. + * @param ctx the parse tree + */ + enterForStatement? (ctx: ForStatementContext): void; + /** + * Exit a parse tree produced by `ApexParser.forStatement`. + * @param ctx the parse tree + */ + exitForStatement? (ctx: ForStatementContext): void; + /** + * Enter a parse tree produced by `ApexParser.whileStatement`. + * @param ctx the parse tree + */ + enterWhileStatement? (ctx: WhileStatementContext): void; + /** + * Exit a parse tree produced by `ApexParser.whileStatement`. + * @param ctx the parse tree + */ + exitWhileStatement? (ctx: WhileStatementContext): void; + /** + * Enter a parse tree produced by `ApexParser.doWhileStatement`. + * @param ctx the parse tree + */ + enterDoWhileStatement? (ctx: DoWhileStatementContext): void; + /** + * Exit a parse tree produced by `ApexParser.doWhileStatement`. + * @param ctx the parse tree + */ + exitDoWhileStatement? (ctx: DoWhileStatementContext): void; + /** + * Enter a parse tree produced by `ApexParser.tryStatement`. + * @param ctx the parse tree + */ + enterTryStatement? (ctx: TryStatementContext): void; + /** + * Exit a parse tree produced by `ApexParser.tryStatement`. + * @param ctx the parse tree + */ + exitTryStatement? (ctx: TryStatementContext): void; + /** + * Enter a parse tree produced by `ApexParser.returnStatement`. + * @param ctx the parse tree + */ + enterReturnStatement? (ctx: ReturnStatementContext): void; + /** + * Exit a parse tree produced by `ApexParser.returnStatement`. + * @param ctx the parse tree + */ + exitReturnStatement? (ctx: ReturnStatementContext): void; + /** + * Enter a parse tree produced by `ApexParser.throwStatement`. + * @param ctx the parse tree + */ + enterThrowStatement? (ctx: ThrowStatementContext): void; + /** + * Exit a parse tree produced by `ApexParser.throwStatement`. + * @param ctx the parse tree + */ + exitThrowStatement? (ctx: ThrowStatementContext): void; + /** + * Enter a parse tree produced by `ApexParser.breakStatement`. + * @param ctx the parse tree + */ + enterBreakStatement? (ctx: BreakStatementContext): void; + /** + * Exit a parse tree produced by `ApexParser.breakStatement`. + * @param ctx the parse tree + */ + exitBreakStatement? (ctx: BreakStatementContext): void; + /** + * Enter a parse tree produced by `ApexParser.continueStatement`. + * @param ctx the parse tree + */ + enterContinueStatement? (ctx: ContinueStatementContext): void; + /** + * Exit a parse tree produced by `ApexParser.continueStatement`. + * @param ctx the parse tree + */ + exitContinueStatement? (ctx: ContinueStatementContext): void; + /** + * Enter a parse tree produced by `ApexParser.accessLevel`. + * @param ctx the parse tree + */ + enterAccessLevel? (ctx: AccessLevelContext): void; + /** + * Exit a parse tree produced by `ApexParser.accessLevel`. + * @param ctx the parse tree + */ + exitAccessLevel? (ctx: AccessLevelContext): void; + /** + * Enter a parse tree produced by `ApexParser.insertStatement`. + * @param ctx the parse tree + */ + enterInsertStatement? (ctx: InsertStatementContext): void; + /** + * Exit a parse tree produced by `ApexParser.insertStatement`. + * @param ctx the parse tree + */ + exitInsertStatement? (ctx: InsertStatementContext): void; + /** + * Enter a parse tree produced by `ApexParser.updateStatement`. + * @param ctx the parse tree + */ + enterUpdateStatement? (ctx: UpdateStatementContext): void; + /** + * Exit a parse tree produced by `ApexParser.updateStatement`. + * @param ctx the parse tree + */ + exitUpdateStatement? (ctx: UpdateStatementContext): void; + /** + * Enter a parse tree produced by `ApexParser.deleteStatement`. + * @param ctx the parse tree + */ + enterDeleteStatement? (ctx: DeleteStatementContext): void; + /** + * Exit a parse tree produced by `ApexParser.deleteStatement`. + * @param ctx the parse tree + */ + exitDeleteStatement? (ctx: DeleteStatementContext): void; + /** + * Enter a parse tree produced by `ApexParser.undeleteStatement`. + * @param ctx the parse tree + */ + enterUndeleteStatement? (ctx: UndeleteStatementContext): void; + /** + * Exit a parse tree produced by `ApexParser.undeleteStatement`. + * @param ctx the parse tree + */ + exitUndeleteStatement? (ctx: UndeleteStatementContext): void; + /** + * Enter a parse tree produced by `ApexParser.upsertStatement`. + * @param ctx the parse tree + */ + enterUpsertStatement? (ctx: UpsertStatementContext): void; + /** + * Exit a parse tree produced by `ApexParser.upsertStatement`. + * @param ctx the parse tree + */ + exitUpsertStatement? (ctx: UpsertStatementContext): void; + /** + * Enter a parse tree produced by `ApexParser.mergeStatement`. + * @param ctx the parse tree + */ + enterMergeStatement? (ctx: MergeStatementContext): void; + /** + * Exit a parse tree produced by `ApexParser.mergeStatement`. + * @param ctx the parse tree + */ + exitMergeStatement? (ctx: MergeStatementContext): void; + /** + * Enter a parse tree produced by `ApexParser.runAsStatement`. + * @param ctx the parse tree + */ + enterRunAsStatement? (ctx: RunAsStatementContext): void; + /** + * Exit a parse tree produced by `ApexParser.runAsStatement`. + * @param ctx the parse tree + */ + exitRunAsStatement? (ctx: RunAsStatementContext): void; + /** + * Enter a parse tree produced by `ApexParser.expressionStatement`. + * @param ctx the parse tree + */ + enterExpressionStatement? (ctx: ExpressionStatementContext): void; + /** + * Exit a parse tree produced by `ApexParser.expressionStatement`. + * @param ctx the parse tree + */ + exitExpressionStatement? (ctx: ExpressionStatementContext): void; + /** + * Enter a parse tree produced by `ApexParser.propertyBlock`. + * @param ctx the parse tree + */ + enterPropertyBlock? (ctx: PropertyBlockContext): void; + /** + * Exit a parse tree produced by `ApexParser.propertyBlock`. + * @param ctx the parse tree + */ + exitPropertyBlock? (ctx: PropertyBlockContext): void; + /** + * Enter a parse tree produced by `ApexParser.getter`. + * @param ctx the parse tree + */ + enterGetter? (ctx: GetterContext): void; + /** + * Exit a parse tree produced by `ApexParser.getter`. + * @param ctx the parse tree + */ + exitGetter? (ctx: GetterContext): void; + /** + * Enter a parse tree produced by `ApexParser.setter`. + * @param ctx the parse tree + */ + enterSetter? (ctx: SetterContext): void; + /** + * Exit a parse tree produced by `ApexParser.setter`. + * @param ctx the parse tree + */ + exitSetter? (ctx: SetterContext): void; + /** + * Enter a parse tree produced by `ApexParser.catchClause`. + * @param ctx the parse tree + */ + enterCatchClause? (ctx: CatchClauseContext): void; + /** + * Exit a parse tree produced by `ApexParser.catchClause`. + * @param ctx the parse tree + */ + exitCatchClause? (ctx: CatchClauseContext): void; + /** + * Enter a parse tree produced by `ApexParser.finallyBlock`. + * @param ctx the parse tree + */ + enterFinallyBlock? (ctx: FinallyBlockContext): void; + /** + * Exit a parse tree produced by `ApexParser.finallyBlock`. + * @param ctx the parse tree + */ + exitFinallyBlock? (ctx: FinallyBlockContext): void; + /** + * Enter a parse tree produced by `ApexParser.forControl`. + * @param ctx the parse tree + */ + enterForControl? (ctx: ForControlContext): void; + /** + * Exit a parse tree produced by `ApexParser.forControl`. + * @param ctx the parse tree + */ + exitForControl? (ctx: ForControlContext): void; + /** + * Enter a parse tree produced by `ApexParser.forInit`. + * @param ctx the parse tree + */ + enterForInit? (ctx: ForInitContext): void; + /** + * Exit a parse tree produced by `ApexParser.forInit`. + * @param ctx the parse tree + */ + exitForInit? (ctx: ForInitContext): void; + /** + * Enter a parse tree produced by `ApexParser.enhancedForControl`. + * @param ctx the parse tree + */ + enterEnhancedForControl? (ctx: EnhancedForControlContext): void; + /** + * Exit a parse tree produced by `ApexParser.enhancedForControl`. + * @param ctx the parse tree + */ + exitEnhancedForControl? (ctx: EnhancedForControlContext): void; + /** + * Enter a parse tree produced by `ApexParser.forUpdate`. + * @param ctx the parse tree + */ + enterForUpdate? (ctx: ForUpdateContext): void; + /** + * Exit a parse tree produced by `ApexParser.forUpdate`. + * @param ctx the parse tree + */ + exitForUpdate? (ctx: ForUpdateContext): void; + /** + * Enter a parse tree produced by `ApexParser.parExpression`. + * @param ctx the parse tree + */ + enterParExpression? (ctx: ParExpressionContext): void; + /** + * Exit a parse tree produced by `ApexParser.parExpression`. + * @param ctx the parse tree + */ + exitParExpression? (ctx: ParExpressionContext): void; + /** + * Enter a parse tree produced by `ApexParser.expressionList`. + * @param ctx the parse tree + */ + enterExpressionList? (ctx: ExpressionListContext): void; + /** + * Exit a parse tree produced by `ApexParser.expressionList`. + * @param ctx the parse tree + */ + exitExpressionList? (ctx: ExpressionListContext): void; + /** + * Enter a parse tree produced by the `primaryExpression` + * labeled alternative in `ApexParser.expression`. + * @param ctx the parse tree + */ + enterPrimaryExpression? (ctx: PrimaryExpressionContext): void; + /** + * Exit a parse tree produced by the `primaryExpression` + * labeled alternative in `ApexParser.expression`. + * @param ctx the parse tree + */ + exitPrimaryExpression? (ctx: PrimaryExpressionContext): void; + /** + * Enter a parse tree produced by the `arth1Expression` + * labeled alternative in `ApexParser.expression`. + * @param ctx the parse tree + */ + enterArth1Expression? (ctx: Arth1ExpressionContext): void; + /** + * Exit a parse tree produced by the `arth1Expression` + * labeled alternative in `ApexParser.expression`. + * @param ctx the parse tree + */ + exitArth1Expression? (ctx: Arth1ExpressionContext): void; + /** + * Enter a parse tree produced by the `dotExpression` + * labeled alternative in `ApexParser.expression`. + * @param ctx the parse tree + */ + enterDotExpression? (ctx: DotExpressionContext): void; + /** + * Exit a parse tree produced by the `dotExpression` + * labeled alternative in `ApexParser.expression`. + * @param ctx the parse tree + */ + exitDotExpression? (ctx: DotExpressionContext): void; + /** + * Enter a parse tree produced by the `bitOrExpression` + * labeled alternative in `ApexParser.expression`. + * @param ctx the parse tree + */ + enterBitOrExpression? (ctx: BitOrExpressionContext): void; + /** + * Exit a parse tree produced by the `bitOrExpression` + * labeled alternative in `ApexParser.expression`. + * @param ctx the parse tree + */ + exitBitOrExpression? (ctx: BitOrExpressionContext): void; + /** + * Enter a parse tree produced by the `arrayExpression` + * labeled alternative in `ApexParser.expression`. + * @param ctx the parse tree + */ + enterArrayExpression? (ctx: ArrayExpressionContext): void; + /** + * Exit a parse tree produced by the `arrayExpression` + * labeled alternative in `ApexParser.expression`. + * @param ctx the parse tree + */ + exitArrayExpression? (ctx: ArrayExpressionContext): void; + /** + * Enter a parse tree produced by the `newExpression` + * labeled alternative in `ApexParser.expression`. + * @param ctx the parse tree + */ + enterNewExpression? (ctx: NewExpressionContext): void; + /** + * Exit a parse tree produced by the `newExpression` + * labeled alternative in `ApexParser.expression`. + * @param ctx the parse tree + */ + exitNewExpression? (ctx: NewExpressionContext): void; + /** + * Enter a parse tree produced by the `assignExpression` + * labeled alternative in `ApexParser.expression`. + * @param ctx the parse tree + */ + enterAssignExpression? (ctx: AssignExpressionContext): void; + /** + * Exit a parse tree produced by the `assignExpression` + * labeled alternative in `ApexParser.expression`. + * @param ctx the parse tree + */ + exitAssignExpression? (ctx: AssignExpressionContext): void; + /** + * Enter a parse tree produced by the `methodCallExpression` + * labeled alternative in `ApexParser.expression`. + * @param ctx the parse tree + */ + enterMethodCallExpression? (ctx: MethodCallExpressionContext): void; + /** + * Exit a parse tree produced by the `methodCallExpression` + * labeled alternative in `ApexParser.expression`. + * @param ctx the parse tree + */ + exitMethodCallExpression? (ctx: MethodCallExpressionContext): void; + /** + * Enter a parse tree produced by the `bitNotExpression` + * labeled alternative in `ApexParser.expression`. + * @param ctx the parse tree + */ + enterBitNotExpression? (ctx: BitNotExpressionContext): void; + /** + * Exit a parse tree produced by the `bitNotExpression` + * labeled alternative in `ApexParser.expression`. + * @param ctx the parse tree + */ + exitBitNotExpression? (ctx: BitNotExpressionContext): void; + /** + * Enter a parse tree produced by the `arth2Expression` + * labeled alternative in `ApexParser.expression`. + * @param ctx the parse tree + */ + enterArth2Expression? (ctx: Arth2ExpressionContext): void; + /** + * Exit a parse tree produced by the `arth2Expression` + * labeled alternative in `ApexParser.expression`. + * @param ctx the parse tree + */ + exitArth2Expression? (ctx: Arth2ExpressionContext): void; + /** + * Enter a parse tree produced by the `logAndExpression` + * labeled alternative in `ApexParser.expression`. + * @param ctx the parse tree + */ + enterLogAndExpression? (ctx: LogAndExpressionContext): void; + /** + * Exit a parse tree produced by the `logAndExpression` + * labeled alternative in `ApexParser.expression`. + * @param ctx the parse tree + */ + exitLogAndExpression? (ctx: LogAndExpressionContext): void; + /** + * Enter a parse tree produced by the `coalescingExpression` + * labeled alternative in `ApexParser.expression`. + * @param ctx the parse tree + */ + enterCoalescingExpression? (ctx: CoalescingExpressionContext): void; + /** + * Exit a parse tree produced by the `coalescingExpression` + * labeled alternative in `ApexParser.expression`. + * @param ctx the parse tree + */ + exitCoalescingExpression? (ctx: CoalescingExpressionContext): void; + /** + * Enter a parse tree produced by the `castExpression` + * labeled alternative in `ApexParser.expression`. + * @param ctx the parse tree + */ + enterCastExpression? (ctx: CastExpressionContext): void; + /** + * Exit a parse tree produced by the `castExpression` + * labeled alternative in `ApexParser.expression`. + * @param ctx the parse tree + */ + exitCastExpression? (ctx: CastExpressionContext): void; + /** + * Enter a parse tree produced by the `bitAndExpression` + * labeled alternative in `ApexParser.expression`. + * @param ctx the parse tree + */ + enterBitAndExpression? (ctx: BitAndExpressionContext): void; + /** + * Exit a parse tree produced by the `bitAndExpression` + * labeled alternative in `ApexParser.expression`. + * @param ctx the parse tree + */ + exitBitAndExpression? (ctx: BitAndExpressionContext): void; + /** + * Enter a parse tree produced by the `cmpExpression` + * labeled alternative in `ApexParser.expression`. + * @param ctx the parse tree + */ + enterCmpExpression? (ctx: CmpExpressionContext): void; + /** + * Exit a parse tree produced by the `cmpExpression` + * labeled alternative in `ApexParser.expression`. + * @param ctx the parse tree + */ + exitCmpExpression? (ctx: CmpExpressionContext): void; + /** + * Enter a parse tree produced by the `bitExpression` + * labeled alternative in `ApexParser.expression`. + * @param ctx the parse tree + */ + enterBitExpression? (ctx: BitExpressionContext): void; + /** + * Exit a parse tree produced by the `bitExpression` + * labeled alternative in `ApexParser.expression`. + * @param ctx the parse tree + */ + exitBitExpression? (ctx: BitExpressionContext): void; + /** + * Enter a parse tree produced by the `logOrExpression` + * labeled alternative in `ApexParser.expression`. + * @param ctx the parse tree + */ + enterLogOrExpression? (ctx: LogOrExpressionContext): void; + /** + * Exit a parse tree produced by the `logOrExpression` + * labeled alternative in `ApexParser.expression`. + * @param ctx the parse tree + */ + exitLogOrExpression? (ctx: LogOrExpressionContext): void; + /** + * Enter a parse tree produced by the `condExpression` + * labeled alternative in `ApexParser.expression`. + * @param ctx the parse tree + */ + enterCondExpression? (ctx: CondExpressionContext): void; + /** + * Exit a parse tree produced by the `condExpression` + * labeled alternative in `ApexParser.expression`. + * @param ctx the parse tree + */ + exitCondExpression? (ctx: CondExpressionContext): void; + /** + * Enter a parse tree produced by the `equalityExpression` + * labeled alternative in `ApexParser.expression`. + * @param ctx the parse tree + */ + enterEqualityExpression? (ctx: EqualityExpressionContext): void; + /** + * Exit a parse tree produced by the `equalityExpression` + * labeled alternative in `ApexParser.expression`. + * @param ctx the parse tree + */ + exitEqualityExpression? (ctx: EqualityExpressionContext): void; + /** + * Enter a parse tree produced by the `postOpExpression` + * labeled alternative in `ApexParser.expression`. + * @param ctx the parse tree + */ + enterPostOpExpression? (ctx: PostOpExpressionContext): void; + /** + * Exit a parse tree produced by the `postOpExpression` + * labeled alternative in `ApexParser.expression`. + * @param ctx the parse tree + */ + exitPostOpExpression? (ctx: PostOpExpressionContext): void; + /** + * Enter a parse tree produced by the `negExpression` + * labeled alternative in `ApexParser.expression`. + * @param ctx the parse tree + */ + enterNegExpression? (ctx: NegExpressionContext): void; + /** + * Exit a parse tree produced by the `negExpression` + * labeled alternative in `ApexParser.expression`. + * @param ctx the parse tree + */ + exitNegExpression? (ctx: NegExpressionContext): void; + /** + * Enter a parse tree produced by the `preOpExpression` + * labeled alternative in `ApexParser.expression`. + * @param ctx the parse tree + */ + enterPreOpExpression? (ctx: PreOpExpressionContext): void; + /** + * Exit a parse tree produced by the `preOpExpression` + * labeled alternative in `ApexParser.expression`. + * @param ctx the parse tree + */ + exitPreOpExpression? (ctx: PreOpExpressionContext): void; + /** + * Enter a parse tree produced by the `subExpression` + * labeled alternative in `ApexParser.expression`. + * @param ctx the parse tree + */ + enterSubExpression? (ctx: SubExpressionContext): void; + /** + * Exit a parse tree produced by the `subExpression` + * labeled alternative in `ApexParser.expression`. + * @param ctx the parse tree + */ + exitSubExpression? (ctx: SubExpressionContext): void; + /** + * Enter a parse tree produced by the `instanceOfExpression` + * labeled alternative in `ApexParser.expression`. + * @param ctx the parse tree + */ + enterInstanceOfExpression? (ctx: InstanceOfExpressionContext): void; + /** + * Exit a parse tree produced by the `instanceOfExpression` + * labeled alternative in `ApexParser.expression`. + * @param ctx the parse tree + */ + exitInstanceOfExpression? (ctx: InstanceOfExpressionContext): void; + /** + * Enter a parse tree produced by the `thisPrimary` + * labeled alternative in `ApexParser.primary`. + * @param ctx the parse tree + */ + enterThisPrimary? (ctx: ThisPrimaryContext): void; + /** + * Exit a parse tree produced by the `thisPrimary` + * labeled alternative in `ApexParser.primary`. + * @param ctx the parse tree + */ + exitThisPrimary? (ctx: ThisPrimaryContext): void; + /** + * Enter a parse tree produced by the `superPrimary` + * labeled alternative in `ApexParser.primary`. + * @param ctx the parse tree + */ + enterSuperPrimary? (ctx: SuperPrimaryContext): void; + /** + * Exit a parse tree produced by the `superPrimary` + * labeled alternative in `ApexParser.primary`. + * @param ctx the parse tree + */ + exitSuperPrimary? (ctx: SuperPrimaryContext): void; + /** + * Enter a parse tree produced by the `literalPrimary` + * labeled alternative in `ApexParser.primary`. + * @param ctx the parse tree + */ + enterLiteralPrimary? (ctx: LiteralPrimaryContext): void; + /** + * Exit a parse tree produced by the `literalPrimary` + * labeled alternative in `ApexParser.primary`. + * @param ctx the parse tree + */ + exitLiteralPrimary? (ctx: LiteralPrimaryContext): void; + /** + * Enter a parse tree produced by the `typeRefPrimary` + * labeled alternative in `ApexParser.primary`. + * @param ctx the parse tree + */ + enterTypeRefPrimary? (ctx: TypeRefPrimaryContext): void; + /** + * Exit a parse tree produced by the `typeRefPrimary` + * labeled alternative in `ApexParser.primary`. + * @param ctx the parse tree + */ + exitTypeRefPrimary? (ctx: TypeRefPrimaryContext): void; + /** + * Enter a parse tree produced by the `voidPrimary` + * labeled alternative in `ApexParser.primary`. + * @param ctx the parse tree + */ + enterVoidPrimary? (ctx: VoidPrimaryContext): void; + /** + * Exit a parse tree produced by the `voidPrimary` + * labeled alternative in `ApexParser.primary`. + * @param ctx the parse tree + */ + exitVoidPrimary? (ctx: VoidPrimaryContext): void; + /** + * Enter a parse tree produced by the `idPrimary` + * labeled alternative in `ApexParser.primary`. + * @param ctx the parse tree + */ + enterIdPrimary? (ctx: IdPrimaryContext): void; + /** + * Exit a parse tree produced by the `idPrimary` + * labeled alternative in `ApexParser.primary`. + * @param ctx the parse tree + */ + exitIdPrimary? (ctx: IdPrimaryContext): void; + /** + * Enter a parse tree produced by the `soqlPrimary` + * labeled alternative in `ApexParser.primary`. + * @param ctx the parse tree + */ + enterSoqlPrimary? (ctx: SoqlPrimaryContext): void; + /** + * Exit a parse tree produced by the `soqlPrimary` + * labeled alternative in `ApexParser.primary`. + * @param ctx the parse tree + */ + exitSoqlPrimary? (ctx: SoqlPrimaryContext): void; + /** + * Enter a parse tree produced by the `soslPrimary` + * labeled alternative in `ApexParser.primary`. + * @param ctx the parse tree + */ + enterSoslPrimary? (ctx: SoslPrimaryContext): void; + /** + * Exit a parse tree produced by the `soslPrimary` + * labeled alternative in `ApexParser.primary`. + * @param ctx the parse tree + */ + exitSoslPrimary? (ctx: SoslPrimaryContext): void; + /** + * Enter a parse tree produced by `ApexParser.methodCall`. + * @param ctx the parse tree + */ + enterMethodCall? (ctx: MethodCallContext): void; + /** + * Exit a parse tree produced by `ApexParser.methodCall`. + * @param ctx the parse tree + */ + exitMethodCall? (ctx: MethodCallContext): void; + /** + * Enter a parse tree produced by `ApexParser.dotMethodCall`. + * @param ctx the parse tree + */ + enterDotMethodCall? (ctx: DotMethodCallContext): void; + /** + * Exit a parse tree produced by `ApexParser.dotMethodCall`. + * @param ctx the parse tree + */ + exitDotMethodCall? (ctx: DotMethodCallContext): void; + /** + * Enter a parse tree produced by `ApexParser.creator`. + * @param ctx the parse tree + */ + enterCreator? (ctx: CreatorContext): void; + /** + * Exit a parse tree produced by `ApexParser.creator`. + * @param ctx the parse tree + */ + exitCreator? (ctx: CreatorContext): void; + /** + * Enter a parse tree produced by `ApexParser.createdName`. + * @param ctx the parse tree + */ + enterCreatedName? (ctx: CreatedNameContext): void; + /** + * Exit a parse tree produced by `ApexParser.createdName`. + * @param ctx the parse tree + */ + exitCreatedName? (ctx: CreatedNameContext): void; + /** + * Enter a parse tree produced by `ApexParser.idCreatedNamePair`. + * @param ctx the parse tree + */ + enterIdCreatedNamePair? (ctx: IdCreatedNamePairContext): void; + /** + * Exit a parse tree produced by `ApexParser.idCreatedNamePair`. + * @param ctx the parse tree + */ + exitIdCreatedNamePair? (ctx: IdCreatedNamePairContext): void; + /** + * Enter a parse tree produced by `ApexParser.noRest`. + * @param ctx the parse tree + */ + enterNoRest? (ctx: NoRestContext): void; + /** + * Exit a parse tree produced by `ApexParser.noRest`. + * @param ctx the parse tree + */ + exitNoRest? (ctx: NoRestContext): void; + /** + * Enter a parse tree produced by `ApexParser.classCreatorRest`. + * @param ctx the parse tree + */ + enterClassCreatorRest? (ctx: ClassCreatorRestContext): void; + /** + * Exit a parse tree produced by `ApexParser.classCreatorRest`. + * @param ctx the parse tree + */ + exitClassCreatorRest? (ctx: ClassCreatorRestContext): void; + /** + * Enter a parse tree produced by `ApexParser.arrayCreatorRest`. + * @param ctx the parse tree + */ + enterArrayCreatorRest? (ctx: ArrayCreatorRestContext): void; + /** + * Exit a parse tree produced by `ApexParser.arrayCreatorRest`. + * @param ctx the parse tree + */ + exitArrayCreatorRest? (ctx: ArrayCreatorRestContext): void; + /** + * Enter a parse tree produced by `ApexParser.mapCreatorRest`. + * @param ctx the parse tree + */ + enterMapCreatorRest? (ctx: MapCreatorRestContext): void; + /** + * Exit a parse tree produced by `ApexParser.mapCreatorRest`. + * @param ctx the parse tree + */ + exitMapCreatorRest? (ctx: MapCreatorRestContext): void; + /** + * Enter a parse tree produced by `ApexParser.mapCreatorRestPair`. + * @param ctx the parse tree + */ + enterMapCreatorRestPair? (ctx: MapCreatorRestPairContext): void; + /** + * Exit a parse tree produced by `ApexParser.mapCreatorRestPair`. + * @param ctx the parse tree + */ + exitMapCreatorRestPair? (ctx: MapCreatorRestPairContext): void; + /** + * Enter a parse tree produced by `ApexParser.setCreatorRest`. + * @param ctx the parse tree + */ + enterSetCreatorRest? (ctx: SetCreatorRestContext): void; + /** + * Exit a parse tree produced by `ApexParser.setCreatorRest`. + * @param ctx the parse tree + */ + exitSetCreatorRest? (ctx: SetCreatorRestContext): void; + /** + * Enter a parse tree produced by `ApexParser.arguments`. + * @param ctx the parse tree + */ + enterArguments? (ctx: ArgumentsContext): void; + /** + * Exit a parse tree produced by `ApexParser.arguments`. + * @param ctx the parse tree + */ + exitArguments? (ctx: ArgumentsContext): void; + /** + * Enter a parse tree produced by `ApexParser.soqlLiteral`. + * @param ctx the parse tree + */ + enterSoqlLiteral? (ctx: SoqlLiteralContext): void; + /** + * Exit a parse tree produced by `ApexParser.soqlLiteral`. + * @param ctx the parse tree + */ + exitSoqlLiteral? (ctx: SoqlLiteralContext): void; + /** + * Enter a parse tree produced by `ApexParser.query`. + * @param ctx the parse tree + */ + enterQuery? (ctx: QueryContext): void; + /** + * Exit a parse tree produced by `ApexParser.query`. + * @param ctx the parse tree + */ + exitQuery? (ctx: QueryContext): void; + /** + * Enter a parse tree produced by `ApexParser.subQuery`. + * @param ctx the parse tree + */ + enterSubQuery? (ctx: SubQueryContext): void; + /** + * Exit a parse tree produced by `ApexParser.subQuery`. + * @param ctx the parse tree + */ + exitSubQuery? (ctx: SubQueryContext): void; + /** + * Enter a parse tree produced by `ApexParser.selectList`. + * @param ctx the parse tree + */ + enterSelectList? (ctx: SelectListContext): void; + /** + * Exit a parse tree produced by `ApexParser.selectList`. + * @param ctx the parse tree + */ + exitSelectList? (ctx: SelectListContext): void; + /** + * Enter a parse tree produced by `ApexParser.selectEntry`. + * @param ctx the parse tree + */ + enterSelectEntry? (ctx: SelectEntryContext): void; + /** + * Exit a parse tree produced by `ApexParser.selectEntry`. + * @param ctx the parse tree + */ + exitSelectEntry? (ctx: SelectEntryContext): void; + /** + * Enter a parse tree produced by `ApexParser.fieldName`. + * @param ctx the parse tree + */ + enterFieldName? (ctx: FieldNameContext): void; + /** + * Exit a parse tree produced by `ApexParser.fieldName`. + * @param ctx the parse tree + */ + exitFieldName? (ctx: FieldNameContext): void; + /** + * Enter a parse tree produced by `ApexParser.fromNameList`. + * @param ctx the parse tree + */ + enterFromNameList? (ctx: FromNameListContext): void; + /** + * Exit a parse tree produced by `ApexParser.fromNameList`. + * @param ctx the parse tree + */ + exitFromNameList? (ctx: FromNameListContext): void; + /** + * Enter a parse tree produced by `ApexParser.subFieldList`. + * @param ctx the parse tree + */ + enterSubFieldList? (ctx: SubFieldListContext): void; + /** + * Exit a parse tree produced by `ApexParser.subFieldList`. + * @param ctx the parse tree + */ + exitSubFieldList? (ctx: SubFieldListContext): void; + /** + * Enter a parse tree produced by `ApexParser.subFieldEntry`. + * @param ctx the parse tree + */ + enterSubFieldEntry? (ctx: SubFieldEntryContext): void; + /** + * Exit a parse tree produced by `ApexParser.subFieldEntry`. + * @param ctx the parse tree + */ + exitSubFieldEntry? (ctx: SubFieldEntryContext): void; + /** + * Enter a parse tree produced by `ApexParser.soqlFieldsParameter`. + * @param ctx the parse tree + */ + enterSoqlFieldsParameter? (ctx: SoqlFieldsParameterContext): void; + /** + * Exit a parse tree produced by `ApexParser.soqlFieldsParameter`. + * @param ctx the parse tree + */ + exitSoqlFieldsParameter? (ctx: SoqlFieldsParameterContext): void; + /** + * Enter a parse tree produced by `ApexParser.soqlFunction`. + * @param ctx the parse tree + */ + enterSoqlFunction? (ctx: SoqlFunctionContext): void; + /** + * Exit a parse tree produced by `ApexParser.soqlFunction`. + * @param ctx the parse tree + */ + exitSoqlFunction? (ctx: SoqlFunctionContext): void; + /** + * Enter a parse tree produced by `ApexParser.dateFieldName`. + * @param ctx the parse tree + */ + enterDateFieldName? (ctx: DateFieldNameContext): void; + /** + * Exit a parse tree produced by `ApexParser.dateFieldName`. + * @param ctx the parse tree + */ + exitDateFieldName? (ctx: DateFieldNameContext): void; + /** + * Enter a parse tree produced by `ApexParser.locationValue`. + * @param ctx the parse tree + */ + enterLocationValue? (ctx: LocationValueContext): void; + /** + * Exit a parse tree produced by `ApexParser.locationValue`. + * @param ctx the parse tree + */ + exitLocationValue? (ctx: LocationValueContext): void; + /** + * Enter a parse tree produced by `ApexParser.coordinateValue`. + * @param ctx the parse tree + */ + enterCoordinateValue? (ctx: CoordinateValueContext): void; + /** + * Exit a parse tree produced by `ApexParser.coordinateValue`. + * @param ctx the parse tree + */ + exitCoordinateValue? (ctx: CoordinateValueContext): void; + /** + * Enter a parse tree produced by `ApexParser.typeOf`. + * @param ctx the parse tree + */ + enterTypeOf? (ctx: TypeOfContext): void; + /** + * Exit a parse tree produced by `ApexParser.typeOf`. + * @param ctx the parse tree + */ + exitTypeOf? (ctx: TypeOfContext): void; + /** + * Enter a parse tree produced by `ApexParser.whenClause`. + * @param ctx the parse tree + */ + enterWhenClause? (ctx: WhenClauseContext): void; + /** + * Exit a parse tree produced by `ApexParser.whenClause`. + * @param ctx the parse tree + */ + exitWhenClause? (ctx: WhenClauseContext): void; + /** + * Enter a parse tree produced by `ApexParser.elseClause`. + * @param ctx the parse tree + */ + enterElseClause? (ctx: ElseClauseContext): void; + /** + * Exit a parse tree produced by `ApexParser.elseClause`. + * @param ctx the parse tree + */ + exitElseClause? (ctx: ElseClauseContext): void; + /** + * Enter a parse tree produced by `ApexParser.fieldNameList`. + * @param ctx the parse tree + */ + enterFieldNameList? (ctx: FieldNameListContext): void; + /** + * Exit a parse tree produced by `ApexParser.fieldNameList`. + * @param ctx the parse tree + */ + exitFieldNameList? (ctx: FieldNameListContext): void; + /** + * Enter a parse tree produced by `ApexParser.usingScope`. + * @param ctx the parse tree + */ + enterUsingScope? (ctx: UsingScopeContext): void; + /** + * Exit a parse tree produced by `ApexParser.usingScope`. + * @param ctx the parse tree + */ + exitUsingScope? (ctx: UsingScopeContext): void; + /** + * Enter a parse tree produced by `ApexParser.whereClause`. + * @param ctx the parse tree + */ + enterWhereClause? (ctx: WhereClauseContext): void; + /** + * Exit a parse tree produced by `ApexParser.whereClause`. + * @param ctx the parse tree + */ + exitWhereClause? (ctx: WhereClauseContext): void; + /** + * Enter a parse tree produced by `ApexParser.logicalExpression`. + * @param ctx the parse tree + */ + enterLogicalExpression? (ctx: LogicalExpressionContext): void; + /** + * Exit a parse tree produced by `ApexParser.logicalExpression`. + * @param ctx the parse tree + */ + exitLogicalExpression? (ctx: LogicalExpressionContext): void; + /** + * Enter a parse tree produced by `ApexParser.conditionalExpression`. + * @param ctx the parse tree + */ + enterConditionalExpression? (ctx: ConditionalExpressionContext): void; + /** + * Exit a parse tree produced by `ApexParser.conditionalExpression`. + * @param ctx the parse tree + */ + exitConditionalExpression? (ctx: ConditionalExpressionContext): void; + /** + * Enter a parse tree produced by `ApexParser.fieldExpression`. + * @param ctx the parse tree + */ + enterFieldExpression? (ctx: FieldExpressionContext): void; + /** + * Exit a parse tree produced by `ApexParser.fieldExpression`. + * @param ctx the parse tree + */ + exitFieldExpression? (ctx: FieldExpressionContext): void; + /** + * Enter a parse tree produced by `ApexParser.comparisonOperator`. + * @param ctx the parse tree + */ + enterComparisonOperator? (ctx: ComparisonOperatorContext): void; + /** + * Exit a parse tree produced by `ApexParser.comparisonOperator`. + * @param ctx the parse tree + */ + exitComparisonOperator? (ctx: ComparisonOperatorContext): void; + /** + * Enter a parse tree produced by `ApexParser.value`. + * @param ctx the parse tree + */ + enterValue? (ctx: ValueContext): void; + /** + * Exit a parse tree produced by `ApexParser.value`. + * @param ctx the parse tree + */ + exitValue? (ctx: ValueContext): void; + /** + * Enter a parse tree produced by `ApexParser.valueList`. + * @param ctx the parse tree + */ + enterValueList? (ctx: ValueListContext): void; + /** + * Exit a parse tree produced by `ApexParser.valueList`. + * @param ctx the parse tree + */ + exitValueList? (ctx: ValueListContext): void; + /** + * Enter a parse tree produced by `ApexParser.signedNumber`. + * @param ctx the parse tree + */ + enterSignedNumber? (ctx: SignedNumberContext): void; + /** + * Exit a parse tree produced by `ApexParser.signedNumber`. + * @param ctx the parse tree + */ + exitSignedNumber? (ctx: SignedNumberContext): void; + /** + * Enter a parse tree produced by `ApexParser.withClause`. + * @param ctx the parse tree + */ + enterWithClause? (ctx: WithClauseContext): void; + /** + * Exit a parse tree produced by `ApexParser.withClause`. + * @param ctx the parse tree + */ + exitWithClause? (ctx: WithClauseContext): void; + /** + * Enter a parse tree produced by `ApexParser.filteringExpression`. + * @param ctx the parse tree + */ + enterFilteringExpression? (ctx: FilteringExpressionContext): void; + /** + * Exit a parse tree produced by `ApexParser.filteringExpression`. + * @param ctx the parse tree + */ + exitFilteringExpression? (ctx: FilteringExpressionContext): void; + /** + * Enter a parse tree produced by `ApexParser.dataCategorySelection`. + * @param ctx the parse tree + */ + enterDataCategorySelection? (ctx: DataCategorySelectionContext): void; + /** + * Exit a parse tree produced by `ApexParser.dataCategorySelection`. + * @param ctx the parse tree + */ + exitDataCategorySelection? (ctx: DataCategorySelectionContext): void; + /** + * Enter a parse tree produced by `ApexParser.dataCategoryName`. + * @param ctx the parse tree + */ + enterDataCategoryName? (ctx: DataCategoryNameContext): void; + /** + * Exit a parse tree produced by `ApexParser.dataCategoryName`. + * @param ctx the parse tree + */ + exitDataCategoryName? (ctx: DataCategoryNameContext): void; + /** + * Enter a parse tree produced by `ApexParser.filteringSelector`. + * @param ctx the parse tree + */ + enterFilteringSelector? (ctx: FilteringSelectorContext): void; + /** + * Exit a parse tree produced by `ApexParser.filteringSelector`. + * @param ctx the parse tree + */ + exitFilteringSelector? (ctx: FilteringSelectorContext): void; + /** + * Enter a parse tree produced by `ApexParser.groupByClause`. + * @param ctx the parse tree + */ + enterGroupByClause? (ctx: GroupByClauseContext): void; + /** + * Exit a parse tree produced by `ApexParser.groupByClause`. + * @param ctx the parse tree + */ + exitGroupByClause? (ctx: GroupByClauseContext): void; + /** + * Enter a parse tree produced by `ApexParser.orderByClause`. + * @param ctx the parse tree + */ + enterOrderByClause? (ctx: OrderByClauseContext): void; + /** + * Exit a parse tree produced by `ApexParser.orderByClause`. + * @param ctx the parse tree + */ + exitOrderByClause? (ctx: OrderByClauseContext): void; + /** + * Enter a parse tree produced by `ApexParser.fieldOrderList`. + * @param ctx the parse tree + */ + enterFieldOrderList? (ctx: FieldOrderListContext): void; + /** + * Exit a parse tree produced by `ApexParser.fieldOrderList`. + * @param ctx the parse tree + */ + exitFieldOrderList? (ctx: FieldOrderListContext): void; + /** + * Enter a parse tree produced by `ApexParser.fieldOrder`. + * @param ctx the parse tree + */ + enterFieldOrder? (ctx: FieldOrderContext): void; + /** + * Exit a parse tree produced by `ApexParser.fieldOrder`. + * @param ctx the parse tree + */ + exitFieldOrder? (ctx: FieldOrderContext): void; + /** + * Enter a parse tree produced by `ApexParser.limitClause`. + * @param ctx the parse tree + */ + enterLimitClause? (ctx: LimitClauseContext): void; + /** + * Exit a parse tree produced by `ApexParser.limitClause`. + * @param ctx the parse tree + */ + exitLimitClause? (ctx: LimitClauseContext): void; + /** + * Enter a parse tree produced by `ApexParser.offsetClause`. + * @param ctx the parse tree + */ + enterOffsetClause? (ctx: OffsetClauseContext): void; + /** + * Exit a parse tree produced by `ApexParser.offsetClause`. + * @param ctx the parse tree + */ + exitOffsetClause? (ctx: OffsetClauseContext): void; + /** + * Enter a parse tree produced by `ApexParser.allRowsClause`. + * @param ctx the parse tree + */ + enterAllRowsClause? (ctx: AllRowsClauseContext): void; + /** + * Exit a parse tree produced by `ApexParser.allRowsClause`. + * @param ctx the parse tree + */ + exitAllRowsClause? (ctx: AllRowsClauseContext): void; + /** + * Enter a parse tree produced by `ApexParser.forClauses`. + * @param ctx the parse tree + */ + enterForClauses? (ctx: ForClausesContext): void; + /** + * Exit a parse tree produced by `ApexParser.forClauses`. + * @param ctx the parse tree + */ + exitForClauses? (ctx: ForClausesContext): void; + /** + * Enter a parse tree produced by `ApexParser.boundExpression`. + * @param ctx the parse tree + */ + enterBoundExpression? (ctx: BoundExpressionContext): void; + /** + * Exit a parse tree produced by `ApexParser.boundExpression`. + * @param ctx the parse tree + */ + exitBoundExpression? (ctx: BoundExpressionContext): void; + /** + * Enter a parse tree produced by `ApexParser.dateFormula`. + * @param ctx the parse tree + */ + enterDateFormula? (ctx: DateFormulaContext): void; + /** + * Exit a parse tree produced by `ApexParser.dateFormula`. + * @param ctx the parse tree + */ + exitDateFormula? (ctx: DateFormulaContext): void; + /** + * Enter a parse tree produced by `ApexParser.signedInteger`. + * @param ctx the parse tree + */ + enterSignedInteger? (ctx: SignedIntegerContext): void; + /** + * Exit a parse tree produced by `ApexParser.signedInteger`. + * @param ctx the parse tree + */ + exitSignedInteger? (ctx: SignedIntegerContext): void; + /** + * Enter a parse tree produced by `ApexParser.soqlId`. + * @param ctx the parse tree + */ + enterSoqlId? (ctx: SoqlIdContext): void; + /** + * Exit a parse tree produced by `ApexParser.soqlId`. + * @param ctx the parse tree + */ + exitSoqlId? (ctx: SoqlIdContext): void; + /** + * Enter a parse tree produced by `ApexParser.soslLiteral`. + * @param ctx the parse tree + */ + enterSoslLiteral? (ctx: SoslLiteralContext): void; + /** + * Exit a parse tree produced by `ApexParser.soslLiteral`. + * @param ctx the parse tree + */ + exitSoslLiteral? (ctx: SoslLiteralContext): void; + /** + * Enter a parse tree produced by `ApexParser.soslLiteralAlt`. + * @param ctx the parse tree + */ + enterSoslLiteralAlt? (ctx: SoslLiteralAltContext): void; + /** + * Exit a parse tree produced by `ApexParser.soslLiteralAlt`. + * @param ctx the parse tree + */ + exitSoslLiteralAlt? (ctx: SoslLiteralAltContext): void; + /** + * Enter a parse tree produced by `ApexParser.soslClauses`. + * @param ctx the parse tree + */ + enterSoslClauses? (ctx: SoslClausesContext): void; + /** + * Exit a parse tree produced by `ApexParser.soslClauses`. + * @param ctx the parse tree + */ + exitSoslClauses? (ctx: SoslClausesContext): void; + /** + * Enter a parse tree produced by `ApexParser.searchGroup`. + * @param ctx the parse tree + */ + enterSearchGroup? (ctx: SearchGroupContext): void; + /** + * Exit a parse tree produced by `ApexParser.searchGroup`. + * @param ctx the parse tree + */ + exitSearchGroup? (ctx: SearchGroupContext): void; + /** + * Enter a parse tree produced by `ApexParser.fieldSpecList`. + * @param ctx the parse tree + */ + enterFieldSpecList? (ctx: FieldSpecListContext): void; + /** + * Exit a parse tree produced by `ApexParser.fieldSpecList`. + * @param ctx the parse tree + */ + exitFieldSpecList? (ctx: FieldSpecListContext): void; + /** + * Enter a parse tree produced by `ApexParser.fieldSpec`. + * @param ctx the parse tree + */ + enterFieldSpec? (ctx: FieldSpecContext): void; + /** + * Exit a parse tree produced by `ApexParser.fieldSpec`. + * @param ctx the parse tree + */ + exitFieldSpec? (ctx: FieldSpecContext): void; + /** + * Enter a parse tree produced by `ApexParser.fieldList`. + * @param ctx the parse tree + */ + enterFieldList? (ctx: FieldListContext): void; + /** + * Exit a parse tree produced by `ApexParser.fieldList`. + * @param ctx the parse tree + */ + exitFieldList? (ctx: FieldListContext): void; + /** + * Enter a parse tree produced by `ApexParser.updateList`. + * @param ctx the parse tree + */ + enterUpdateList? (ctx: UpdateListContext): void; + /** + * Exit a parse tree produced by `ApexParser.updateList`. + * @param ctx the parse tree + */ + exitUpdateList? (ctx: UpdateListContext): void; + /** + * Enter a parse tree produced by `ApexParser.updateType`. + * @param ctx the parse tree + */ + enterUpdateType? (ctx: UpdateTypeContext): void; + /** + * Exit a parse tree produced by `ApexParser.updateType`. + * @param ctx the parse tree + */ + exitUpdateType? (ctx: UpdateTypeContext): void; + /** + * Enter a parse tree produced by `ApexParser.networkList`. + * @param ctx the parse tree + */ + enterNetworkList? (ctx: NetworkListContext): void; + /** + * Exit a parse tree produced by `ApexParser.networkList`. + * @param ctx the parse tree + */ + exitNetworkList? (ctx: NetworkListContext): void; + /** + * Enter a parse tree produced by `ApexParser.soslId`. + * @param ctx the parse tree + */ + enterSoslId? (ctx: SoslIdContext): void; + /** + * Exit a parse tree produced by `ApexParser.soslId`. + * @param ctx the parse tree + */ + exitSoslId? (ctx: SoslIdContext): void; + /** + * Enter a parse tree produced by `ApexParser.id`. + * @param ctx the parse tree + */ + enterId? (ctx: IdContext): void; + /** + * Exit a parse tree produced by `ApexParser.id`. + * @param ctx the parse tree + */ + exitId? (ctx: IdContext): void; + /** + * Enter a parse tree produced by `ApexParser.anyId`. + * @param ctx the parse tree + */ + enterAnyId? (ctx: AnyIdContext): void; + /** + * Exit a parse tree produced by `ApexParser.anyId`. + * @param ctx the parse tree + */ + exitAnyId? (ctx: AnyIdContext): void; + + visitTerminal(node: TerminalNode): void {} // eslint-disable-line + visitErrorNode(node: ErrorNode): void {} // eslint-disable-line + enterEveryRule(node: ParserRuleContext): void {} // eslint-disable-line + exitEveryRule(node: ParserRuleContext): void {} // eslint-disable-line +} + diff --git a/packages/apex/src/grammar/ApexParserVisitor.ts b/packages/apex/src/grammar/ApexParserVisitor.ts new file mode 100644 index 00000000..a95525e9 --- /dev/null +++ b/packages/apex/src/grammar/ApexParserVisitor.ts @@ -0,0 +1,1269 @@ +// Generated from ./grammar/ApexParser.g4 by ANTLR 4.13.1 + +import { AbstractParseTreeVisitor } from "antlr4ng"; + + +import { TriggerUnitContext } from "./ApexParser.js"; +import { TriggerCaseContext } from "./ApexParser.js"; +import { CompilationUnitContext } from "./ApexParser.js"; +import { TypeDeclarationContext } from "./ApexParser.js"; +import { ClassDeclarationContext } from "./ApexParser.js"; +import { EnumDeclarationContext } from "./ApexParser.js"; +import { EnumConstantsContext } from "./ApexParser.js"; +import { InterfaceDeclarationContext } from "./ApexParser.js"; +import { TypeListContext } from "./ApexParser.js"; +import { ClassBodyContext } from "./ApexParser.js"; +import { InterfaceBodyContext } from "./ApexParser.js"; +import { ClassBodyDeclarationContext } from "./ApexParser.js"; +import { ModifierContext } from "./ApexParser.js"; +import { MemberDeclarationContext } from "./ApexParser.js"; +import { MethodDeclarationContext } from "./ApexParser.js"; +import { ConstructorDeclarationContext } from "./ApexParser.js"; +import { FieldDeclarationContext } from "./ApexParser.js"; +import { PropertyDeclarationContext } from "./ApexParser.js"; +import { InterfaceMethodDeclarationContext } from "./ApexParser.js"; +import { VariableDeclaratorsContext } from "./ApexParser.js"; +import { VariableDeclaratorContext } from "./ApexParser.js"; +import { ArrayInitializerContext } from "./ApexParser.js"; +import { TypeRefContext } from "./ApexParser.js"; +import { ArraySubscriptsContext } from "./ApexParser.js"; +import { TypeNameContext } from "./ApexParser.js"; +import { TypeArgumentsContext } from "./ApexParser.js"; +import { FormalParametersContext } from "./ApexParser.js"; +import { FormalParameterListContext } from "./ApexParser.js"; +import { FormalParameterContext } from "./ApexParser.js"; +import { QualifiedNameContext } from "./ApexParser.js"; +import { LiteralContext } from "./ApexParser.js"; +import { AnnotationContext } from "./ApexParser.js"; +import { ElementValuePairsContext } from "./ApexParser.js"; +import { ElementValuePairContext } from "./ApexParser.js"; +import { ElementValueContext } from "./ApexParser.js"; +import { ElementValueArrayInitializerContext } from "./ApexParser.js"; +import { BlockContext } from "./ApexParser.js"; +import { LocalVariableDeclarationStatementContext } from "./ApexParser.js"; +import { LocalVariableDeclarationContext } from "./ApexParser.js"; +import { StatementContext } from "./ApexParser.js"; +import { IfStatementContext } from "./ApexParser.js"; +import { SwitchStatementContext } from "./ApexParser.js"; +import { WhenControlContext } from "./ApexParser.js"; +import { WhenValueContext } from "./ApexParser.js"; +import { WhenLiteralContext } from "./ApexParser.js"; +import { ForStatementContext } from "./ApexParser.js"; +import { WhileStatementContext } from "./ApexParser.js"; +import { DoWhileStatementContext } from "./ApexParser.js"; +import { TryStatementContext } from "./ApexParser.js"; +import { ReturnStatementContext } from "./ApexParser.js"; +import { ThrowStatementContext } from "./ApexParser.js"; +import { BreakStatementContext } from "./ApexParser.js"; +import { ContinueStatementContext } from "./ApexParser.js"; +import { AccessLevelContext } from "./ApexParser.js"; +import { InsertStatementContext } from "./ApexParser.js"; +import { UpdateStatementContext } from "./ApexParser.js"; +import { DeleteStatementContext } from "./ApexParser.js"; +import { UndeleteStatementContext } from "./ApexParser.js"; +import { UpsertStatementContext } from "./ApexParser.js"; +import { MergeStatementContext } from "./ApexParser.js"; +import { RunAsStatementContext } from "./ApexParser.js"; +import { ExpressionStatementContext } from "./ApexParser.js"; +import { PropertyBlockContext } from "./ApexParser.js"; +import { GetterContext } from "./ApexParser.js"; +import { SetterContext } from "./ApexParser.js"; +import { CatchClauseContext } from "./ApexParser.js"; +import { FinallyBlockContext } from "./ApexParser.js"; +import { ForControlContext } from "./ApexParser.js"; +import { ForInitContext } from "./ApexParser.js"; +import { EnhancedForControlContext } from "./ApexParser.js"; +import { ForUpdateContext } from "./ApexParser.js"; +import { ParExpressionContext } from "./ApexParser.js"; +import { ExpressionListContext } from "./ApexParser.js"; +import { PrimaryExpressionContext } from "./ApexParser.js"; +import { Arth1ExpressionContext } from "./ApexParser.js"; +import { DotExpressionContext } from "./ApexParser.js"; +import { BitOrExpressionContext } from "./ApexParser.js"; +import { ArrayExpressionContext } from "./ApexParser.js"; +import { NewExpressionContext } from "./ApexParser.js"; +import { AssignExpressionContext } from "./ApexParser.js"; +import { MethodCallExpressionContext } from "./ApexParser.js"; +import { BitNotExpressionContext } from "./ApexParser.js"; +import { Arth2ExpressionContext } from "./ApexParser.js"; +import { LogAndExpressionContext } from "./ApexParser.js"; +import { CoalescingExpressionContext } from "./ApexParser.js"; +import { CastExpressionContext } from "./ApexParser.js"; +import { BitAndExpressionContext } from "./ApexParser.js"; +import { CmpExpressionContext } from "./ApexParser.js"; +import { BitExpressionContext } from "./ApexParser.js"; +import { LogOrExpressionContext } from "./ApexParser.js"; +import { CondExpressionContext } from "./ApexParser.js"; +import { EqualityExpressionContext } from "./ApexParser.js"; +import { PostOpExpressionContext } from "./ApexParser.js"; +import { NegExpressionContext } from "./ApexParser.js"; +import { PreOpExpressionContext } from "./ApexParser.js"; +import { SubExpressionContext } from "./ApexParser.js"; +import { InstanceOfExpressionContext } from "./ApexParser.js"; +import { ThisPrimaryContext } from "./ApexParser.js"; +import { SuperPrimaryContext } from "./ApexParser.js"; +import { LiteralPrimaryContext } from "./ApexParser.js"; +import { TypeRefPrimaryContext } from "./ApexParser.js"; +import { VoidPrimaryContext } from "./ApexParser.js"; +import { IdPrimaryContext } from "./ApexParser.js"; +import { SoqlPrimaryContext } from "./ApexParser.js"; +import { SoslPrimaryContext } from "./ApexParser.js"; +import { MethodCallContext } from "./ApexParser.js"; +import { DotMethodCallContext } from "./ApexParser.js"; +import { CreatorContext } from "./ApexParser.js"; +import { CreatedNameContext } from "./ApexParser.js"; +import { IdCreatedNamePairContext } from "./ApexParser.js"; +import { NoRestContext } from "./ApexParser.js"; +import { ClassCreatorRestContext } from "./ApexParser.js"; +import { ArrayCreatorRestContext } from "./ApexParser.js"; +import { MapCreatorRestContext } from "./ApexParser.js"; +import { MapCreatorRestPairContext } from "./ApexParser.js"; +import { SetCreatorRestContext } from "./ApexParser.js"; +import { ArgumentsContext } from "./ApexParser.js"; +import { SoqlLiteralContext } from "./ApexParser.js"; +import { QueryContext } from "./ApexParser.js"; +import { SubQueryContext } from "./ApexParser.js"; +import { SelectListContext } from "./ApexParser.js"; +import { SelectEntryContext } from "./ApexParser.js"; +import { FieldNameContext } from "./ApexParser.js"; +import { FromNameListContext } from "./ApexParser.js"; +import { SubFieldListContext } from "./ApexParser.js"; +import { SubFieldEntryContext } from "./ApexParser.js"; +import { SoqlFieldsParameterContext } from "./ApexParser.js"; +import { SoqlFunctionContext } from "./ApexParser.js"; +import { DateFieldNameContext } from "./ApexParser.js"; +import { LocationValueContext } from "./ApexParser.js"; +import { CoordinateValueContext } from "./ApexParser.js"; +import { TypeOfContext } from "./ApexParser.js"; +import { WhenClauseContext } from "./ApexParser.js"; +import { ElseClauseContext } from "./ApexParser.js"; +import { FieldNameListContext } from "./ApexParser.js"; +import { UsingScopeContext } from "./ApexParser.js"; +import { WhereClauseContext } from "./ApexParser.js"; +import { LogicalExpressionContext } from "./ApexParser.js"; +import { ConditionalExpressionContext } from "./ApexParser.js"; +import { FieldExpressionContext } from "./ApexParser.js"; +import { ComparisonOperatorContext } from "./ApexParser.js"; +import { ValueContext } from "./ApexParser.js"; +import { ValueListContext } from "./ApexParser.js"; +import { SignedNumberContext } from "./ApexParser.js"; +import { WithClauseContext } from "./ApexParser.js"; +import { FilteringExpressionContext } from "./ApexParser.js"; +import { DataCategorySelectionContext } from "./ApexParser.js"; +import { DataCategoryNameContext } from "./ApexParser.js"; +import { FilteringSelectorContext } from "./ApexParser.js"; +import { GroupByClauseContext } from "./ApexParser.js"; +import { OrderByClauseContext } from "./ApexParser.js"; +import { FieldOrderListContext } from "./ApexParser.js"; +import { FieldOrderContext } from "./ApexParser.js"; +import { LimitClauseContext } from "./ApexParser.js"; +import { OffsetClauseContext } from "./ApexParser.js"; +import { AllRowsClauseContext } from "./ApexParser.js"; +import { ForClausesContext } from "./ApexParser.js"; +import { BoundExpressionContext } from "./ApexParser.js"; +import { DateFormulaContext } from "./ApexParser.js"; +import { SignedIntegerContext } from "./ApexParser.js"; +import { SoqlIdContext } from "./ApexParser.js"; +import { SoslLiteralContext } from "./ApexParser.js"; +import { SoslLiteralAltContext } from "./ApexParser.js"; +import { SoslClausesContext } from "./ApexParser.js"; +import { SearchGroupContext } from "./ApexParser.js"; +import { FieldSpecListContext } from "./ApexParser.js"; +import { FieldSpecContext } from "./ApexParser.js"; +import { FieldListContext } from "./ApexParser.js"; +import { UpdateListContext } from "./ApexParser.js"; +import { UpdateTypeContext } from "./ApexParser.js"; +import { NetworkListContext } from "./ApexParser.js"; +import { SoslIdContext } from "./ApexParser.js"; +import { IdContext } from "./ApexParser.js"; +import { AnyIdContext } from "./ApexParser.js"; + +// Regex: (\w+)\?: (\([^\)]+\)) => (\w+); +// Replace: $1? $2: $3; \1? \2: \3; + +/** + * This interface defines a complete generic visitor for a parse tree produced + * by `ApexParser`. + * + * @param The return type of the visit operation. Use `void` for + * operations with no return type. + */ +export class ApexParserVisitor extends AbstractParseTreeVisitor { + /** + * Visit a parse tree produced by `ApexParser.triggerUnit`. + * @param ctx the parse tree + * @return the visitor result + */ + visitTriggerUnit? (ctx: TriggerUnitContext): Result; + /** + * Visit a parse tree produced by `ApexParser.triggerCase`. + * @param ctx the parse tree + * @return the visitor result + */ + visitTriggerCase? (ctx: TriggerCaseContext): Result; + /** + * Visit a parse tree produced by `ApexParser.compilationUnit`. + * @param ctx the parse tree + * @return the visitor result + */ + visitCompilationUnit? (ctx: CompilationUnitContext): Result; + /** + * Visit a parse tree produced by `ApexParser.typeDeclaration`. + * @param ctx the parse tree + * @return the visitor result + */ + visitTypeDeclaration? (ctx: TypeDeclarationContext): Result; + /** + * Visit a parse tree produced by `ApexParser.classDeclaration`. + * @param ctx the parse tree + * @return the visitor result + */ + visitClassDeclaration? (ctx: ClassDeclarationContext): Result; + /** + * Visit a parse tree produced by `ApexParser.enumDeclaration`. + * @param ctx the parse tree + * @return the visitor result + */ + visitEnumDeclaration? (ctx: EnumDeclarationContext): Result; + /** + * Visit a parse tree produced by `ApexParser.enumConstants`. + * @param ctx the parse tree + * @return the visitor result + */ + visitEnumConstants? (ctx: EnumConstantsContext): Result; + /** + * Visit a parse tree produced by `ApexParser.interfaceDeclaration`. + * @param ctx the parse tree + * @return the visitor result + */ + visitInterfaceDeclaration? (ctx: InterfaceDeclarationContext): Result; + /** + * Visit a parse tree produced by `ApexParser.typeList`. + * @param ctx the parse tree + * @return the visitor result + */ + visitTypeList? (ctx: TypeListContext): Result; + /** + * Visit a parse tree produced by `ApexParser.classBody`. + * @param ctx the parse tree + * @return the visitor result + */ + visitClassBody? (ctx: ClassBodyContext): Result; + /** + * Visit a parse tree produced by `ApexParser.interfaceBody`. + * @param ctx the parse tree + * @return the visitor result + */ + visitInterfaceBody? (ctx: InterfaceBodyContext): Result; + /** + * Visit a parse tree produced by `ApexParser.classBodyDeclaration`. + * @param ctx the parse tree + * @return the visitor result + */ + visitClassBodyDeclaration? (ctx: ClassBodyDeclarationContext): Result; + /** + * Visit a parse tree produced by `ApexParser.modifier`. + * @param ctx the parse tree + * @return the visitor result + */ + visitModifier? (ctx: ModifierContext): Result; + /** + * Visit a parse tree produced by `ApexParser.memberDeclaration`. + * @param ctx the parse tree + * @return the visitor result + */ + visitMemberDeclaration? (ctx: MemberDeclarationContext): Result; + /** + * Visit a parse tree produced by `ApexParser.methodDeclaration`. + * @param ctx the parse tree + * @return the visitor result + */ + visitMethodDeclaration? (ctx: MethodDeclarationContext): Result; + /** + * Visit a parse tree produced by `ApexParser.constructorDeclaration`. + * @param ctx the parse tree + * @return the visitor result + */ + visitConstructorDeclaration? (ctx: ConstructorDeclarationContext): Result; + /** + * Visit a parse tree produced by `ApexParser.fieldDeclaration`. + * @param ctx the parse tree + * @return the visitor result + */ + visitFieldDeclaration? (ctx: FieldDeclarationContext): Result; + /** + * Visit a parse tree produced by `ApexParser.propertyDeclaration`. + * @param ctx the parse tree + * @return the visitor result + */ + visitPropertyDeclaration? (ctx: PropertyDeclarationContext): Result; + /** + * Visit a parse tree produced by `ApexParser.interfaceMethodDeclaration`. + * @param ctx the parse tree + * @return the visitor result + */ + visitInterfaceMethodDeclaration? (ctx: InterfaceMethodDeclarationContext): Result; + /** + * Visit a parse tree produced by `ApexParser.variableDeclarators`. + * @param ctx the parse tree + * @return the visitor result + */ + visitVariableDeclarators? (ctx: VariableDeclaratorsContext): Result; + /** + * Visit a parse tree produced by `ApexParser.variableDeclarator`. + * @param ctx the parse tree + * @return the visitor result + */ + visitVariableDeclarator? (ctx: VariableDeclaratorContext): Result; + /** + * Visit a parse tree produced by `ApexParser.arrayInitializer`. + * @param ctx the parse tree + * @return the visitor result + */ + visitArrayInitializer? (ctx: ArrayInitializerContext): Result; + /** + * Visit a parse tree produced by `ApexParser.typeRef`. + * @param ctx the parse tree + * @return the visitor result + */ + visitTypeRef? (ctx: TypeRefContext): Result; + /** + * Visit a parse tree produced by `ApexParser.arraySubscripts`. + * @param ctx the parse tree + * @return the visitor result + */ + visitArraySubscripts? (ctx: ArraySubscriptsContext): Result; + /** + * Visit a parse tree produced by `ApexParser.typeName`. + * @param ctx the parse tree + * @return the visitor result + */ + visitTypeName? (ctx: TypeNameContext): Result; + /** + * Visit a parse tree produced by `ApexParser.typeArguments`. + * @param ctx the parse tree + * @return the visitor result + */ + visitTypeArguments? (ctx: TypeArgumentsContext): Result; + /** + * Visit a parse tree produced by `ApexParser.formalParameters`. + * @param ctx the parse tree + * @return the visitor result + */ + visitFormalParameters? (ctx: FormalParametersContext): Result; + /** + * Visit a parse tree produced by `ApexParser.formalParameterList`. + * @param ctx the parse tree + * @return the visitor result + */ + visitFormalParameterList? (ctx: FormalParameterListContext): Result; + /** + * Visit a parse tree produced by `ApexParser.formalParameter`. + * @param ctx the parse tree + * @return the visitor result + */ + visitFormalParameter? (ctx: FormalParameterContext): Result; + /** + * Visit a parse tree produced by `ApexParser.qualifiedName`. + * @param ctx the parse tree + * @return the visitor result + */ + visitQualifiedName? (ctx: QualifiedNameContext): Result; + /** + * Visit a parse tree produced by `ApexParser.literal`. + * @param ctx the parse tree + * @return the visitor result + */ + visitLiteral? (ctx: LiteralContext): Result; + /** + * Visit a parse tree produced by `ApexParser.annotation`. + * @param ctx the parse tree + * @return the visitor result + */ + visitAnnotation? (ctx: AnnotationContext): Result; + /** + * Visit a parse tree produced by `ApexParser.elementValuePairs`. + * @param ctx the parse tree + * @return the visitor result + */ + visitElementValuePairs? (ctx: ElementValuePairsContext): Result; + /** + * Visit a parse tree produced by `ApexParser.elementValuePair`. + * @param ctx the parse tree + * @return the visitor result + */ + visitElementValuePair? (ctx: ElementValuePairContext): Result; + /** + * Visit a parse tree produced by `ApexParser.elementValue`. + * @param ctx the parse tree + * @return the visitor result + */ + visitElementValue? (ctx: ElementValueContext): Result; + /** + * Visit a parse tree produced by `ApexParser.elementValueArrayInitializer`. + * @param ctx the parse tree + * @return the visitor result + */ + visitElementValueArrayInitializer? (ctx: ElementValueArrayInitializerContext): Result; + /** + * Visit a parse tree produced by `ApexParser.block`. + * @param ctx the parse tree + * @return the visitor result + */ + visitBlock? (ctx: BlockContext): Result; + /** + * Visit a parse tree produced by `ApexParser.localVariableDeclarationStatement`. + * @param ctx the parse tree + * @return the visitor result + */ + visitLocalVariableDeclarationStatement? (ctx: LocalVariableDeclarationStatementContext): Result; + /** + * Visit a parse tree produced by `ApexParser.localVariableDeclaration`. + * @param ctx the parse tree + * @return the visitor result + */ + visitLocalVariableDeclaration? (ctx: LocalVariableDeclarationContext): Result; + /** + * Visit a parse tree produced by `ApexParser.statement`. + * @param ctx the parse tree + * @return the visitor result + */ + visitStatement? (ctx: StatementContext): Result; + /** + * Visit a parse tree produced by `ApexParser.ifStatement`. + * @param ctx the parse tree + * @return the visitor result + */ + visitIfStatement? (ctx: IfStatementContext): Result; + /** + * Visit a parse tree produced by `ApexParser.switchStatement`. + * @param ctx the parse tree + * @return the visitor result + */ + visitSwitchStatement? (ctx: SwitchStatementContext): Result; + /** + * Visit a parse tree produced by `ApexParser.whenControl`. + * @param ctx the parse tree + * @return the visitor result + */ + visitWhenControl? (ctx: WhenControlContext): Result; + /** + * Visit a parse tree produced by `ApexParser.whenValue`. + * @param ctx the parse tree + * @return the visitor result + */ + visitWhenValue? (ctx: WhenValueContext): Result; + /** + * Visit a parse tree produced by `ApexParser.whenLiteral`. + * @param ctx the parse tree + * @return the visitor result + */ + visitWhenLiteral? (ctx: WhenLiteralContext): Result; + /** + * Visit a parse tree produced by `ApexParser.forStatement`. + * @param ctx the parse tree + * @return the visitor result + */ + visitForStatement? (ctx: ForStatementContext): Result; + /** + * Visit a parse tree produced by `ApexParser.whileStatement`. + * @param ctx the parse tree + * @return the visitor result + */ + visitWhileStatement? (ctx: WhileStatementContext): Result; + /** + * Visit a parse tree produced by `ApexParser.doWhileStatement`. + * @param ctx the parse tree + * @return the visitor result + */ + visitDoWhileStatement? (ctx: DoWhileStatementContext): Result; + /** + * Visit a parse tree produced by `ApexParser.tryStatement`. + * @param ctx the parse tree + * @return the visitor result + */ + visitTryStatement? (ctx: TryStatementContext): Result; + /** + * Visit a parse tree produced by `ApexParser.returnStatement`. + * @param ctx the parse tree + * @return the visitor result + */ + visitReturnStatement? (ctx: ReturnStatementContext): Result; + /** + * Visit a parse tree produced by `ApexParser.throwStatement`. + * @param ctx the parse tree + * @return the visitor result + */ + visitThrowStatement? (ctx: ThrowStatementContext): Result; + /** + * Visit a parse tree produced by `ApexParser.breakStatement`. + * @param ctx the parse tree + * @return the visitor result + */ + visitBreakStatement? (ctx: BreakStatementContext): Result; + /** + * Visit a parse tree produced by `ApexParser.continueStatement`. + * @param ctx the parse tree + * @return the visitor result + */ + visitContinueStatement? (ctx: ContinueStatementContext): Result; + /** + * Visit a parse tree produced by `ApexParser.accessLevel`. + * @param ctx the parse tree + * @return the visitor result + */ + visitAccessLevel? (ctx: AccessLevelContext): Result; + /** + * Visit a parse tree produced by `ApexParser.insertStatement`. + * @param ctx the parse tree + * @return the visitor result + */ + visitInsertStatement? (ctx: InsertStatementContext): Result; + /** + * Visit a parse tree produced by `ApexParser.updateStatement`. + * @param ctx the parse tree + * @return the visitor result + */ + visitUpdateStatement? (ctx: UpdateStatementContext): Result; + /** + * Visit a parse tree produced by `ApexParser.deleteStatement`. + * @param ctx the parse tree + * @return the visitor result + */ + visitDeleteStatement? (ctx: DeleteStatementContext): Result; + /** + * Visit a parse tree produced by `ApexParser.undeleteStatement`. + * @param ctx the parse tree + * @return the visitor result + */ + visitUndeleteStatement? (ctx: UndeleteStatementContext): Result; + /** + * Visit a parse tree produced by `ApexParser.upsertStatement`. + * @param ctx the parse tree + * @return the visitor result + */ + visitUpsertStatement? (ctx: UpsertStatementContext): Result; + /** + * Visit a parse tree produced by `ApexParser.mergeStatement`. + * @param ctx the parse tree + * @return the visitor result + */ + visitMergeStatement? (ctx: MergeStatementContext): Result; + /** + * Visit a parse tree produced by `ApexParser.runAsStatement`. + * @param ctx the parse tree + * @return the visitor result + */ + visitRunAsStatement? (ctx: RunAsStatementContext): Result; + /** + * Visit a parse tree produced by `ApexParser.expressionStatement`. + * @param ctx the parse tree + * @return the visitor result + */ + visitExpressionStatement? (ctx: ExpressionStatementContext): Result; + /** + * Visit a parse tree produced by `ApexParser.propertyBlock`. + * @param ctx the parse tree + * @return the visitor result + */ + visitPropertyBlock? (ctx: PropertyBlockContext): Result; + /** + * Visit a parse tree produced by `ApexParser.getter`. + * @param ctx the parse tree + * @return the visitor result + */ + visitGetter? (ctx: GetterContext): Result; + /** + * Visit a parse tree produced by `ApexParser.setter`. + * @param ctx the parse tree + * @return the visitor result + */ + visitSetter? (ctx: SetterContext): Result; + /** + * Visit a parse tree produced by `ApexParser.catchClause`. + * @param ctx the parse tree + * @return the visitor result + */ + visitCatchClause? (ctx: CatchClauseContext): Result; + /** + * Visit a parse tree produced by `ApexParser.finallyBlock`. + * @param ctx the parse tree + * @return the visitor result + */ + visitFinallyBlock? (ctx: FinallyBlockContext): Result; + /** + * Visit a parse tree produced by `ApexParser.forControl`. + * @param ctx the parse tree + * @return the visitor result + */ + visitForControl? (ctx: ForControlContext): Result; + /** + * Visit a parse tree produced by `ApexParser.forInit`. + * @param ctx the parse tree + * @return the visitor result + */ + visitForInit? (ctx: ForInitContext): Result; + /** + * Visit a parse tree produced by `ApexParser.enhancedForControl`. + * @param ctx the parse tree + * @return the visitor result + */ + visitEnhancedForControl? (ctx: EnhancedForControlContext): Result; + /** + * Visit a parse tree produced by `ApexParser.forUpdate`. + * @param ctx the parse tree + * @return the visitor result + */ + visitForUpdate? (ctx: ForUpdateContext): Result; + /** + * Visit a parse tree produced by `ApexParser.parExpression`. + * @param ctx the parse tree + * @return the visitor result + */ + visitParExpression? (ctx: ParExpressionContext): Result; + /** + * Visit a parse tree produced by `ApexParser.expressionList`. + * @param ctx the parse tree + * @return the visitor result + */ + visitExpressionList? (ctx: ExpressionListContext): Result; + /** + * Visit a parse tree produced by the `primaryExpression` + * labeled alternative in `ApexParser.expression`. + * @param ctx the parse tree + * @return the visitor result + */ + visitPrimaryExpression? (ctx: PrimaryExpressionContext): Result; + /** + * Visit a parse tree produced by the `arth1Expression` + * labeled alternative in `ApexParser.expression`. + * @param ctx the parse tree + * @return the visitor result + */ + visitArth1Expression? (ctx: Arth1ExpressionContext): Result; + /** + * Visit a parse tree produced by the `dotExpression` + * labeled alternative in `ApexParser.expression`. + * @param ctx the parse tree + * @return the visitor result + */ + visitDotExpression? (ctx: DotExpressionContext): Result; + /** + * Visit a parse tree produced by the `bitOrExpression` + * labeled alternative in `ApexParser.expression`. + * @param ctx the parse tree + * @return the visitor result + */ + visitBitOrExpression? (ctx: BitOrExpressionContext): Result; + /** + * Visit a parse tree produced by the `arrayExpression` + * labeled alternative in `ApexParser.expression`. + * @param ctx the parse tree + * @return the visitor result + */ + visitArrayExpression? (ctx: ArrayExpressionContext): Result; + /** + * Visit a parse tree produced by the `newExpression` + * labeled alternative in `ApexParser.expression`. + * @param ctx the parse tree + * @return the visitor result + */ + visitNewExpression? (ctx: NewExpressionContext): Result; + /** + * Visit a parse tree produced by the `assignExpression` + * labeled alternative in `ApexParser.expression`. + * @param ctx the parse tree + * @return the visitor result + */ + visitAssignExpression? (ctx: AssignExpressionContext): Result; + /** + * Visit a parse tree produced by the `methodCallExpression` + * labeled alternative in `ApexParser.expression`. + * @param ctx the parse tree + * @return the visitor result + */ + visitMethodCallExpression? (ctx: MethodCallExpressionContext): Result; + /** + * Visit a parse tree produced by the `bitNotExpression` + * labeled alternative in `ApexParser.expression`. + * @param ctx the parse tree + * @return the visitor result + */ + visitBitNotExpression? (ctx: BitNotExpressionContext): Result; + /** + * Visit a parse tree produced by the `arth2Expression` + * labeled alternative in `ApexParser.expression`. + * @param ctx the parse tree + * @return the visitor result + */ + visitArth2Expression? (ctx: Arth2ExpressionContext): Result; + /** + * Visit a parse tree produced by the `logAndExpression` + * labeled alternative in `ApexParser.expression`. + * @param ctx the parse tree + * @return the visitor result + */ + visitLogAndExpression? (ctx: LogAndExpressionContext): Result; + /** + * Visit a parse tree produced by the `coalescingExpression` + * labeled alternative in `ApexParser.expression`. + * @param ctx the parse tree + * @return the visitor result + */ + visitCoalescingExpression? (ctx: CoalescingExpressionContext): Result; + /** + * Visit a parse tree produced by the `castExpression` + * labeled alternative in `ApexParser.expression`. + * @param ctx the parse tree + * @return the visitor result + */ + visitCastExpression? (ctx: CastExpressionContext): Result; + /** + * Visit a parse tree produced by the `bitAndExpression` + * labeled alternative in `ApexParser.expression`. + * @param ctx the parse tree + * @return the visitor result + */ + visitBitAndExpression? (ctx: BitAndExpressionContext): Result; + /** + * Visit a parse tree produced by the `cmpExpression` + * labeled alternative in `ApexParser.expression`. + * @param ctx the parse tree + * @return the visitor result + */ + visitCmpExpression? (ctx: CmpExpressionContext): Result; + /** + * Visit a parse tree produced by the `bitExpression` + * labeled alternative in `ApexParser.expression`. + * @param ctx the parse tree + * @return the visitor result + */ + visitBitExpression? (ctx: BitExpressionContext): Result; + /** + * Visit a parse tree produced by the `logOrExpression` + * labeled alternative in `ApexParser.expression`. + * @param ctx the parse tree + * @return the visitor result + */ + visitLogOrExpression? (ctx: LogOrExpressionContext): Result; + /** + * Visit a parse tree produced by the `condExpression` + * labeled alternative in `ApexParser.expression`. + * @param ctx the parse tree + * @return the visitor result + */ + visitCondExpression? (ctx: CondExpressionContext): Result; + /** + * Visit a parse tree produced by the `equalityExpression` + * labeled alternative in `ApexParser.expression`. + * @param ctx the parse tree + * @return the visitor result + */ + visitEqualityExpression? (ctx: EqualityExpressionContext): Result; + /** + * Visit a parse tree produced by the `postOpExpression` + * labeled alternative in `ApexParser.expression`. + * @param ctx the parse tree + * @return the visitor result + */ + visitPostOpExpression? (ctx: PostOpExpressionContext): Result; + /** + * Visit a parse tree produced by the `negExpression` + * labeled alternative in `ApexParser.expression`. + * @param ctx the parse tree + * @return the visitor result + */ + visitNegExpression? (ctx: NegExpressionContext): Result; + /** + * Visit a parse tree produced by the `preOpExpression` + * labeled alternative in `ApexParser.expression`. + * @param ctx the parse tree + * @return the visitor result + */ + visitPreOpExpression? (ctx: PreOpExpressionContext): Result; + /** + * Visit a parse tree produced by the `subExpression` + * labeled alternative in `ApexParser.expression`. + * @param ctx the parse tree + * @return the visitor result + */ + visitSubExpression? (ctx: SubExpressionContext): Result; + /** + * Visit a parse tree produced by the `instanceOfExpression` + * labeled alternative in `ApexParser.expression`. + * @param ctx the parse tree + * @return the visitor result + */ + visitInstanceOfExpression? (ctx: InstanceOfExpressionContext): Result; + /** + * Visit a parse tree produced by the `thisPrimary` + * labeled alternative in `ApexParser.primary`. + * @param ctx the parse tree + * @return the visitor result + */ + visitThisPrimary? (ctx: ThisPrimaryContext): Result; + /** + * Visit a parse tree produced by the `superPrimary` + * labeled alternative in `ApexParser.primary`. + * @param ctx the parse tree + * @return the visitor result + */ + visitSuperPrimary? (ctx: SuperPrimaryContext): Result; + /** + * Visit a parse tree produced by the `literalPrimary` + * labeled alternative in `ApexParser.primary`. + * @param ctx the parse tree + * @return the visitor result + */ + visitLiteralPrimary? (ctx: LiteralPrimaryContext): Result; + /** + * Visit a parse tree produced by the `typeRefPrimary` + * labeled alternative in `ApexParser.primary`. + * @param ctx the parse tree + * @return the visitor result + */ + visitTypeRefPrimary? (ctx: TypeRefPrimaryContext): Result; + /** + * Visit a parse tree produced by the `voidPrimary` + * labeled alternative in `ApexParser.primary`. + * @param ctx the parse tree + * @return the visitor result + */ + visitVoidPrimary? (ctx: VoidPrimaryContext): Result; + /** + * Visit a parse tree produced by the `idPrimary` + * labeled alternative in `ApexParser.primary`. + * @param ctx the parse tree + * @return the visitor result + */ + visitIdPrimary? (ctx: IdPrimaryContext): Result; + /** + * Visit a parse tree produced by the `soqlPrimary` + * labeled alternative in `ApexParser.primary`. + * @param ctx the parse tree + * @return the visitor result + */ + visitSoqlPrimary? (ctx: SoqlPrimaryContext): Result; + /** + * Visit a parse tree produced by the `soslPrimary` + * labeled alternative in `ApexParser.primary`. + * @param ctx the parse tree + * @return the visitor result + */ + visitSoslPrimary? (ctx: SoslPrimaryContext): Result; + /** + * Visit a parse tree produced by `ApexParser.methodCall`. + * @param ctx the parse tree + * @return the visitor result + */ + visitMethodCall? (ctx: MethodCallContext): Result; + /** + * Visit a parse tree produced by `ApexParser.dotMethodCall`. + * @param ctx the parse tree + * @return the visitor result + */ + visitDotMethodCall? (ctx: DotMethodCallContext): Result; + /** + * Visit a parse tree produced by `ApexParser.creator`. + * @param ctx the parse tree + * @return the visitor result + */ + visitCreator? (ctx: CreatorContext): Result; + /** + * Visit a parse tree produced by `ApexParser.createdName`. + * @param ctx the parse tree + * @return the visitor result + */ + visitCreatedName? (ctx: CreatedNameContext): Result; + /** + * Visit a parse tree produced by `ApexParser.idCreatedNamePair`. + * @param ctx the parse tree + * @return the visitor result + */ + visitIdCreatedNamePair? (ctx: IdCreatedNamePairContext): Result; + /** + * Visit a parse tree produced by `ApexParser.noRest`. + * @param ctx the parse tree + * @return the visitor result + */ + visitNoRest? (ctx: NoRestContext): Result; + /** + * Visit a parse tree produced by `ApexParser.classCreatorRest`. + * @param ctx the parse tree + * @return the visitor result + */ + visitClassCreatorRest? (ctx: ClassCreatorRestContext): Result; + /** + * Visit a parse tree produced by `ApexParser.arrayCreatorRest`. + * @param ctx the parse tree + * @return the visitor result + */ + visitArrayCreatorRest? (ctx: ArrayCreatorRestContext): Result; + /** + * Visit a parse tree produced by `ApexParser.mapCreatorRest`. + * @param ctx the parse tree + * @return the visitor result + */ + visitMapCreatorRest? (ctx: MapCreatorRestContext): Result; + /** + * Visit a parse tree produced by `ApexParser.mapCreatorRestPair`. + * @param ctx the parse tree + * @return the visitor result + */ + visitMapCreatorRestPair? (ctx: MapCreatorRestPairContext): Result; + /** + * Visit a parse tree produced by `ApexParser.setCreatorRest`. + * @param ctx the parse tree + * @return the visitor result + */ + visitSetCreatorRest? (ctx: SetCreatorRestContext): Result; + /** + * Visit a parse tree produced by `ApexParser.arguments`. + * @param ctx the parse tree + * @return the visitor result + */ + visitArguments? (ctx: ArgumentsContext): Result; + /** + * Visit a parse tree produced by `ApexParser.soqlLiteral`. + * @param ctx the parse tree + * @return the visitor result + */ + visitSoqlLiteral? (ctx: SoqlLiteralContext): Result; + /** + * Visit a parse tree produced by `ApexParser.query`. + * @param ctx the parse tree + * @return the visitor result + */ + visitQuery? (ctx: QueryContext): Result; + /** + * Visit a parse tree produced by `ApexParser.subQuery`. + * @param ctx the parse tree + * @return the visitor result + */ + visitSubQuery? (ctx: SubQueryContext): Result; + /** + * Visit a parse tree produced by `ApexParser.selectList`. + * @param ctx the parse tree + * @return the visitor result + */ + visitSelectList? (ctx: SelectListContext): Result; + /** + * Visit a parse tree produced by `ApexParser.selectEntry`. + * @param ctx the parse tree + * @return the visitor result + */ + visitSelectEntry? (ctx: SelectEntryContext): Result; + /** + * Visit a parse tree produced by `ApexParser.fieldName`. + * @param ctx the parse tree + * @return the visitor result + */ + visitFieldName? (ctx: FieldNameContext): Result; + /** + * Visit a parse tree produced by `ApexParser.fromNameList`. + * @param ctx the parse tree + * @return the visitor result + */ + visitFromNameList? (ctx: FromNameListContext): Result; + /** + * Visit a parse tree produced by `ApexParser.subFieldList`. + * @param ctx the parse tree + * @return the visitor result + */ + visitSubFieldList? (ctx: SubFieldListContext): Result; + /** + * Visit a parse tree produced by `ApexParser.subFieldEntry`. + * @param ctx the parse tree + * @return the visitor result + */ + visitSubFieldEntry? (ctx: SubFieldEntryContext): Result; + /** + * Visit a parse tree produced by `ApexParser.soqlFieldsParameter`. + * @param ctx the parse tree + * @return the visitor result + */ + visitSoqlFieldsParameter? (ctx: SoqlFieldsParameterContext): Result; + /** + * Visit a parse tree produced by `ApexParser.soqlFunction`. + * @param ctx the parse tree + * @return the visitor result + */ + visitSoqlFunction? (ctx: SoqlFunctionContext): Result; + /** + * Visit a parse tree produced by `ApexParser.dateFieldName`. + * @param ctx the parse tree + * @return the visitor result + */ + visitDateFieldName? (ctx: DateFieldNameContext): Result; + /** + * Visit a parse tree produced by `ApexParser.locationValue`. + * @param ctx the parse tree + * @return the visitor result + */ + visitLocationValue? (ctx: LocationValueContext): Result; + /** + * Visit a parse tree produced by `ApexParser.coordinateValue`. + * @param ctx the parse tree + * @return the visitor result + */ + visitCoordinateValue? (ctx: CoordinateValueContext): Result; + /** + * Visit a parse tree produced by `ApexParser.typeOf`. + * @param ctx the parse tree + * @return the visitor result + */ + visitTypeOf? (ctx: TypeOfContext): Result; + /** + * Visit a parse tree produced by `ApexParser.whenClause`. + * @param ctx the parse tree + * @return the visitor result + */ + visitWhenClause? (ctx: WhenClauseContext): Result; + /** + * Visit a parse tree produced by `ApexParser.elseClause`. + * @param ctx the parse tree + * @return the visitor result + */ + visitElseClause? (ctx: ElseClauseContext): Result; + /** + * Visit a parse tree produced by `ApexParser.fieldNameList`. + * @param ctx the parse tree + * @return the visitor result + */ + visitFieldNameList? (ctx: FieldNameListContext): Result; + /** + * Visit a parse tree produced by `ApexParser.usingScope`. + * @param ctx the parse tree + * @return the visitor result + */ + visitUsingScope? (ctx: UsingScopeContext): Result; + /** + * Visit a parse tree produced by `ApexParser.whereClause`. + * @param ctx the parse tree + * @return the visitor result + */ + visitWhereClause? (ctx: WhereClauseContext): Result; + /** + * Visit a parse tree produced by `ApexParser.logicalExpression`. + * @param ctx the parse tree + * @return the visitor result + */ + visitLogicalExpression? (ctx: LogicalExpressionContext): Result; + /** + * Visit a parse tree produced by `ApexParser.conditionalExpression`. + * @param ctx the parse tree + * @return the visitor result + */ + visitConditionalExpression? (ctx: ConditionalExpressionContext): Result; + /** + * Visit a parse tree produced by `ApexParser.fieldExpression`. + * @param ctx the parse tree + * @return the visitor result + */ + visitFieldExpression? (ctx: FieldExpressionContext): Result; + /** + * Visit a parse tree produced by `ApexParser.comparisonOperator`. + * @param ctx the parse tree + * @return the visitor result + */ + visitComparisonOperator? (ctx: ComparisonOperatorContext): Result; + /** + * Visit a parse tree produced by `ApexParser.value`. + * @param ctx the parse tree + * @return the visitor result + */ + visitValue? (ctx: ValueContext): Result; + /** + * Visit a parse tree produced by `ApexParser.valueList`. + * @param ctx the parse tree + * @return the visitor result + */ + visitValueList? (ctx: ValueListContext): Result; + /** + * Visit a parse tree produced by `ApexParser.signedNumber`. + * @param ctx the parse tree + * @return the visitor result + */ + visitSignedNumber? (ctx: SignedNumberContext): Result; + /** + * Visit a parse tree produced by `ApexParser.withClause`. + * @param ctx the parse tree + * @return the visitor result + */ + visitWithClause? (ctx: WithClauseContext): Result; + /** + * Visit a parse tree produced by `ApexParser.filteringExpression`. + * @param ctx the parse tree + * @return the visitor result + */ + visitFilteringExpression? (ctx: FilteringExpressionContext): Result; + /** + * Visit a parse tree produced by `ApexParser.dataCategorySelection`. + * @param ctx the parse tree + * @return the visitor result + */ + visitDataCategorySelection? (ctx: DataCategorySelectionContext): Result; + /** + * Visit a parse tree produced by `ApexParser.dataCategoryName`. + * @param ctx the parse tree + * @return the visitor result + */ + visitDataCategoryName? (ctx: DataCategoryNameContext): Result; + /** + * Visit a parse tree produced by `ApexParser.filteringSelector`. + * @param ctx the parse tree + * @return the visitor result + */ + visitFilteringSelector? (ctx: FilteringSelectorContext): Result; + /** + * Visit a parse tree produced by `ApexParser.groupByClause`. + * @param ctx the parse tree + * @return the visitor result + */ + visitGroupByClause? (ctx: GroupByClauseContext): Result; + /** + * Visit a parse tree produced by `ApexParser.orderByClause`. + * @param ctx the parse tree + * @return the visitor result + */ + visitOrderByClause? (ctx: OrderByClauseContext): Result; + /** + * Visit a parse tree produced by `ApexParser.fieldOrderList`. + * @param ctx the parse tree + * @return the visitor result + */ + visitFieldOrderList? (ctx: FieldOrderListContext): Result; + /** + * Visit a parse tree produced by `ApexParser.fieldOrder`. + * @param ctx the parse tree + * @return the visitor result + */ + visitFieldOrder? (ctx: FieldOrderContext): Result; + /** + * Visit a parse tree produced by `ApexParser.limitClause`. + * @param ctx the parse tree + * @return the visitor result + */ + visitLimitClause? (ctx: LimitClauseContext): Result; + /** + * Visit a parse tree produced by `ApexParser.offsetClause`. + * @param ctx the parse tree + * @return the visitor result + */ + visitOffsetClause? (ctx: OffsetClauseContext): Result; + /** + * Visit a parse tree produced by `ApexParser.allRowsClause`. + * @param ctx the parse tree + * @return the visitor result + */ + visitAllRowsClause? (ctx: AllRowsClauseContext): Result; + /** + * Visit a parse tree produced by `ApexParser.forClauses`. + * @param ctx the parse tree + * @return the visitor result + */ + visitForClauses? (ctx: ForClausesContext): Result; + /** + * Visit a parse tree produced by `ApexParser.boundExpression`. + * @param ctx the parse tree + * @return the visitor result + */ + visitBoundExpression? (ctx: BoundExpressionContext): Result; + /** + * Visit a parse tree produced by `ApexParser.dateFormula`. + * @param ctx the parse tree + * @return the visitor result + */ + visitDateFormula? (ctx: DateFormulaContext): Result; + /** + * Visit a parse tree produced by `ApexParser.signedInteger`. + * @param ctx the parse tree + * @return the visitor result + */ + visitSignedInteger? (ctx: SignedIntegerContext): Result; + /** + * Visit a parse tree produced by `ApexParser.soqlId`. + * @param ctx the parse tree + * @return the visitor result + */ + visitSoqlId? (ctx: SoqlIdContext): Result; + /** + * Visit a parse tree produced by `ApexParser.soslLiteral`. + * @param ctx the parse tree + * @return the visitor result + */ + visitSoslLiteral? (ctx: SoslLiteralContext): Result; + /** + * Visit a parse tree produced by `ApexParser.soslLiteralAlt`. + * @param ctx the parse tree + * @return the visitor result + */ + visitSoslLiteralAlt? (ctx: SoslLiteralAltContext): Result; + /** + * Visit a parse tree produced by `ApexParser.soslClauses`. + * @param ctx the parse tree + * @return the visitor result + */ + visitSoslClauses? (ctx: SoslClausesContext): Result; + /** + * Visit a parse tree produced by `ApexParser.searchGroup`. + * @param ctx the parse tree + * @return the visitor result + */ + visitSearchGroup? (ctx: SearchGroupContext): Result; + /** + * Visit a parse tree produced by `ApexParser.fieldSpecList`. + * @param ctx the parse tree + * @return the visitor result + */ + visitFieldSpecList? (ctx: FieldSpecListContext): Result; + /** + * Visit a parse tree produced by `ApexParser.fieldSpec`. + * @param ctx the parse tree + * @return the visitor result + */ + visitFieldSpec? (ctx: FieldSpecContext): Result; + /** + * Visit a parse tree produced by `ApexParser.fieldList`. + * @param ctx the parse tree + * @return the visitor result + */ + visitFieldList? (ctx: FieldListContext): Result; + /** + * Visit a parse tree produced by `ApexParser.updateList`. + * @param ctx the parse tree + * @return the visitor result + */ + visitUpdateList? (ctx: UpdateListContext): Result; + /** + * Visit a parse tree produced by `ApexParser.updateType`. + * @param ctx the parse tree + * @return the visitor result + */ + visitUpdateType? (ctx: UpdateTypeContext): Result; + /** + * Visit a parse tree produced by `ApexParser.networkList`. + * @param ctx the parse tree + * @return the visitor result + */ + visitNetworkList? (ctx: NetworkListContext): Result; + /** + * Visit a parse tree produced by `ApexParser.soslId`. + * @param ctx the parse tree + * @return the visitor result + */ + visitSoslId? (ctx: SoslIdContext): Result; + /** + * Visit a parse tree produced by `ApexParser.id`. + * @param ctx the parse tree + * @return the visitor result + */ + visitId? (ctx: IdContext): Result; + /** + * Visit a parse tree produced by `ApexParser.anyId`. + * @param ctx the parse tree + * @return the visitor result + */ + visitAnyId? (ctx: AnyIdContext): Result; +} + diff --git a/packages/apex/src/grammar/index.ts b/packages/apex/src/grammar/index.ts new file mode 100644 index 00000000..c12d80a5 --- /dev/null +++ b/packages/apex/src/grammar/index.ts @@ -0,0 +1,4 @@ +export * from './ApexParser'; +export * from './ApexLexer'; +export * from './ApexParserListener'; +export * from './ApexParserVisitor'; \ No newline at end of file diff --git a/packages/apex/src/index.ts b/packages/apex/src/index.ts new file mode 100644 index 00000000..f9afa928 --- /dev/null +++ b/packages/apex/src/index.ts @@ -0,0 +1,3 @@ +export * from './types'; +export * from './parser'; +export * from './grammar'; diff --git a/packages/apex/src/parser.ts b/packages/apex/src/parser.ts new file mode 100644 index 00000000..c7c1c583 --- /dev/null +++ b/packages/apex/src/parser.ts @@ -0,0 +1,81 @@ +import { CommonTokenStream, CharStream } from 'antlr4ng'; + +import { ApexCompilationUnit, ApexTypeRef } from "./types"; +import { TypeRefCollector } from "./visitors/typeRefCollector"; +import { CompilationUnitVisitor } from "./visitors/compilationUnitVisitor"; +import { BufferStream } from "./streams"; +import { ApexParser, ApexLexer, CompilationUnitContext, TriggerUnitContext } from "./grammar"; + +/** + * APEX Source code parser and lexer. Provides methods to parse APEX source + * code into an abstract syntax tree (AST) and to get all referenced types in the source code. + * + * @example + * ```typescript + * // cu will hold an abstract representation of the code structure of the source files + * // multiple source files can be parsed at once by concatenating them + * const cu = new Parser('public class MyClass { } public class OtherClass { }').getCodeStructure(); + * // refs will hold an array of ll external references: [ 'MyClass', 'BaseClass' ]; + * const refs = new Parser('public class MyClass extends BaseClass { private MyOtherClass other; }').getReferencedTypes(); + * ``` + */ +export class Parser { + + private lexer: ApexLexer; + private parser: ApexParser; + private cu: CompilationUnitContext | TriggerUnitContext; + + constructor(private input: Buffer | string) { + } + + /** + * Parse a piece of Apex code into an abstract representation of the code structure of an APEX source files. + * Returns a {@link ApexCompilationUnit} object that contains all classes and interfaces defined in the source text. The + * source text can be a single file or multiple files concatenated or an array of source texts. + * @param code Apex code to parse as a string or buffer (or an array of strings or buffers) + * @returns An {@link ApexCompilationUnit} describing the code structure + */ + public getCodeStructure(): ApexCompilationUnit { + return this.parseAsCompilationUnit().accept(new CompilationUnitVisitor())!; + } + + /** + * Get all referenced types in the specified code + * @param code Apex code to parse + * @param options Options to control which types are returned + * @returns An array of unique `ApexTypeRef` objects + */ + public getReferencedTypes(options?: { excludeSystemTypes?: boolean }): ApexTypeRef[] { + return this.parseAsCompilationUnit().accept(new TypeRefCollector(options))!; + } + + private parseAsCompilationUnit() { + if (!this.cu) { + this.cu = this.getParser().compilationUnit(); + } + return this.cu; + } + + private getParser(): ApexParser { + if (!this.parser) { + const tokens = new CommonTokenStream(this.getLexer()); + this.parser = new ApexParser(tokens); + } + this.parser.reset(); + return this.parser; + } + + private getLexer(): ApexLexer { + if (!this.lexer) { + this.lexer = new ApexLexer(this.createInputStream()); + } + return this.lexer; + } + + private createInputStream() { + if (typeof this.input === 'string') { + return CharStream.fromString(this.input); + } + return new BufferStream(this.input); + } +} \ No newline at end of file diff --git a/packages/apex/src/standardNamespace.json b/packages/apex/src/standardNamespace.json new file mode 100644 index 00000000..d561fb7b --- /dev/null +++ b/packages/apex/src/standardNamespace.json @@ -0,0 +1,46 @@ +[ + "ApexPages", + "AppLauncher", + "Approval", + "Auth", + "Cache", + "Canvas", + "ChatterAnswers", + "CommercePayments", + "Compression", + "ConnectApi", + "Database", + "Datacloud", + "DataSource", + "DataWeave", + "Dom", + "EventBus", + "Flow", + "FormulaEval", + "Functions", + "Invocable", + "IsvPartners", + "KbManagement", + "LxScheduler", + "Messaging", + "Metadata", + "Pref_center", + "Process", + "QuickAction", + "Reports", + "RichMessaging", + "Schema", + "Search", + "Sfc", + "sfdc_checkout", + "sfdc_surveys", + "Site", + "Slack", + "Support", + "System", + "TerritoryMgmt", + "TxnSecurity", + "UserProvisioning", + "VisualEditor", + "Wave" +] diff --git a/packages/apex/src/streams.ts b/packages/apex/src/streams.ts new file mode 100644 index 00000000..1910ae06 --- /dev/null +++ b/packages/apex/src/streams.ts @@ -0,0 +1,149 @@ +import { CharStream, Token, Interval } from 'antlr4ng'; + +/** + * Implementation of the {@link CharStream} interface that uses a {@link Buffer} as the underlying data source. + */ +export class BufferStream implements CharStream { + + public readonly size: number; + public get index() { return this.#index; } + + #strData: string; + #index = 0; + + constructor( + private data: Buffer, + public readonly name: string = '' + ) { + this.size = this.data.length; + } + + getSourceName(): string { + return this.name; + } + + /** + * Reset the stream so that it's in the same state it was + * when the object was created *except* the data array is not + * touched. + */ + public reset() { + this.#index = 0; + } + + public consume() { + if (this.#index >= this.size) { + // assert this.LA(1) == Token.EOF + throw ("cannot consume EOF"); + } + this.#index += 1; + } + + public LA(offset: number): number { + if (offset === 0) { + return 0; // undefined + } + if (offset < 0) { + offset += 1; // e.g., translate LA(-1) to use offset=0 + } + const pos = this.index + offset - 1; + if (pos < 0 || pos >= this.size) { // invalid + return Token.EOF; + } + return this.data[pos]; + } + + public LT(offset: number): number { + return this.LA(offset); + } + + public mark(): number { + return -1; + } + + public release(): void { + // no resources to release + } + + /** + * consume() ahead until p==index; can't just set p=index as we must + * update line and column. If we seek backwards, just set p + */ + public seek(index: number) { + if (index <= this.index) { + this.#index = index; // just jump; don't update stream state (line, ...) + return; + } + // seek forward + this.#index = Math.min(index, this.size); + } + + public getTextFromRange(start: number, stop: number): string { + return this.getText(Interval.of(start, stop)); + } + + public getTextFromInterval(interval: Interval): string { + return this.getText(interval); + } + + public getText(interval: number | Interval, stop?: number) { + const start = typeof interval === 'number' ? interval : interval.start; + stop = typeof interval === 'number' ? stop! : interval.stop; + + if (stop >= this.size) { + stop = this.size - 1; + } + if (start >= this.size) { + return ''; + } + return this.data.subarray(start, stop + 1).toString(); + } + + public toString() { + if (!this.#strData) { + this.#strData = this.data.toString(); + } + return this.#strData; + } +} + +/** + * Case insensitive Decorator for a `CharStream` implementation, this will make the `LA` method return the lower case + * character code for any character that is not `Token.EOF`. + */ +export class CaseInsensitiveCharStream implements CharStream { + public get index() { return this.stream.index; } + public get size() { return this.stream.size; } + + /** + * Implementation of the `CharStream` interface that is case insensitive. + * @param input Original input stream to decorate as case insensitive + */ + constructor(private stream: CharStream) { + } + + public LA(offset: number): number { + const c = this.stream.LA(offset); + return c === Token.EOF ? c : this.toLower(c); + } + + private toLower(c: number): number { + return (c >= 65 && c <= 90) ? c+32 : c; + } + + public getTextFromRange(start: number, stop: number): string { + return this.stream.getTextFromRange(start, stop); + } + + public getTextFromInterval(interval: Interval): string { + return this.stream.getTextFromInterval(interval); + } + + public reset(): void { this.stream.reset(); } + public consume(): void { this.stream.consume(); } + public mark(): number { return this.stream.mark(); } + public release(marker: number): void { this.stream.release(marker); } + public seek(index: number): void { this.stream.seek(index); } + public toString(): string { return this.stream.toString(); } + public getSourceName(): string { return this.stream.getSourceName(); } +} \ No newline at end of file diff --git a/packages/apex/src/testIndentifier.ts b/packages/apex/src/testIndentifier.ts new file mode 100644 index 00000000..4bdbc9cb --- /dev/null +++ b/packages/apex/src/testIndentifier.ts @@ -0,0 +1,195 @@ +import { Logger, LogManager, FileSystem, container, injectable, LifecyclePolicy } from '@vlocode/core'; +import { Timer, stringEqualsIgnoreCase } from '@vlocode/util'; +import path from 'path'; + +import { ApexClass } from './types'; +import { Parser } from './parser'; + +interface ApexClassInfo { + name: string, + file: string, + isAbstract: boolean, + isTest: boolean, + classStructure: ApexClass +} + +interface ApexTestClassInfo { + name: string, + file: string, + classCoverage: string[], + testMethods: { + methodName: string, + classCoverage: string[] + }[] +} + +/** + * This class can be used to identify test classes that cover a given Apex class, it + * does so by parsing the source files and identifying test classes. + * + * The class is injectable and depends on the `FileSystem` and `Logger` services. These services can be injected + * by the dependency injection container see {@link container} + * + * @example + * ```typescript + * const testIdentifier = container.create(TestIdentifier); + * await testIdentifier.loadApexClasses([ 'path/to/apex/classes' ]); + * const testClasses = testIdentifier.getTestClasses('MyClass'); + * ``` + */ +@injectable({ lifecycle: LifecyclePolicy.transient }) +export class TestIdentifier { + + /** + * Full path of the file to the apex class name. + */ + private fileToApexClass: Map = new Map(); + + /** + * Map of Apex class information by name class name (lowercase) + */ + private apexClassesByName: Map = new Map(); + + /** + * Set of test class names + */ + private testClasses: Map = new Map(); + + constructor( + private fileSystem: FileSystem, + private logger: Logger = LogManager.get('apex-test-identifier') + ) { + } + + /** + * Loads the Apex classes from the specified folders and populates the testClasses map. + * + * @param folders - An array of folder paths containing the Apex classes. + * @returns A promise that resolves when the Apex classes are loaded and testClasses map is populated. + */ + public async loadApexClasses(folders: string[]) { + const timerAll = new Timer(); + + const loadedFiles = await this.parseSourceFiles(folders); + const testClasses = loadedFiles.filter((info) => info.classStructure.methods.some(method => method.isTest)); + testClasses.forEach(testClass => this.testClasses.set(testClass.name.toLowerCase(), { + name: testClass.name, + file: testClass.file, + classCoverage: testClass.classStructure.methods + .filter(method => method.isTest) + .flatMap(method => method.refs.filter(ref => !ref.isSystemType)) + .map(ref => ref.name.toLowerCase()), + testMethods: testClass.classStructure.methods + .filter(method => method.isTest) + .map(method => ({ + methodName: method.name, + classCoverage: method.refs.filter(ref => !ref.isSystemType).map(ref => ref.name.toLowerCase()) + })), + })); + + this.logger.info(`Loaded ${loadedFiles.length} sources (${testClasses.length} test classes) in ${timerAll.toString('ms')}`); + } + + /** + * Retrieves the test classes that cover a given class, optionally include test classes for classes that reference the given class. + * The depth parameter controls how many levels of references to include, if not specified only direct test classes are returned. + * + * If the class is not found, undefined is returned; if no test classes are found, an empty array is returned. + * + * @param className - The name of the class to retrieve test classes for. + * @param options - Optional parameters for controlling the depth of the search. + * @returns An array of test class names that cover the specified class. + */ + public getTestClasses(className: string, options?: { depth?: number }) { + const classInfo = this.apexClassesByName.get(className.toLowerCase()); + if (!classInfo) { + return undefined; + } + + const testClasses = new Set(); + for (const testClass of this.testClasses.values()) { + if (testClass.classCoverage.includes(className.toLowerCase())) { + testClasses.add(testClass.name); + } + } + + if (options?.depth) { + for (const referenceClassName of this.getClassReferences(className)) { + this.getTestClasses(referenceClassName, { depth: options.depth - 1 }) + ?.forEach(testClass => testClasses.add(testClass)) + } + } + + return [...testClasses]; + } + + /** + * Retrieves an Array class that references the given class. + * @param className The name of the class to retrieve references for. + * @returns An array of class names that reference the given class. + */ + private getClassReferences(className: string) { + const references = new Set(); + for (const classInfo of this.apexClassesByName.values()) { + if (classInfo.classStructure.refs.some(ref => stringEqualsIgnoreCase(ref.name, className))) { + references.add(classInfo.name); + } + } + return [...references]; + } + + private async parseSourceFiles(folders: string[]) { + const sourceFiles = new Array(); + + for (const folder of folders) { + this.logger.verbose(`Parsing source files in: ${folder}`); + + for await (const { buffer, file } of this.readSourceFiles(folder)) { + const apexClassName = this.fileToApexClass.get(file); + if (apexClassName) { + sourceFiles.push(this.apexClassesByName.get(apexClassName.toLowerCase())!); + continue; + } + + const parseTimer = new Timer(); + const parser = new Parser(buffer); + const struct = parser.getCodeStructure(); + + for (const classInfo of struct.classes) { + const sourceData = { + classStructure: classInfo, + name: classInfo.name, + file, + isAbstract: !!classInfo.isAbstract, + isTest: !!classInfo.isTest, + }; + + this.fileToApexClass.set(file, classInfo.name); + this.apexClassesByName.set(classInfo.name.toLowerCase(), sourceData); + + sourceFiles.push(sourceData); + } + + this.logger.verbose(`Parsed: ${file} (${parseTimer.toString('ms')})`); + } + } + + return sourceFiles; + } + + private async* readSourceFiles(folder: string){ + for (const file of await this.fileSystem.readDirectory(folder)) { + const fullPath = path.join(folder, file.name); + if (file.isDirectory()) { + yield* this.readSourceFiles(fullPath); + } + if (file.isFile() && file.name.endsWith('.cls') /* || file.name.endsWith('.trigger') */) { + yield { + buffer: await this.fileSystem.readFile(fullPath), + fullPath, + file: file.name + }; + } + } + } +} \ No newline at end of file diff --git a/packages/apex/src/types.ts b/packages/apex/src/types.ts new file mode 100644 index 00000000..b8d7da80 --- /dev/null +++ b/packages/apex/src/types.ts @@ -0,0 +1,191 @@ +import { Token } from "antlr4ng"; +import stdNamespaceData from './standardNamespace.json'; + +export type ApexAccessModifier = 'global' | 'public' | 'protected' | 'private'; +export type ApexClassModifier = 'virtual' | 'abstract'; +export type ApexSharingModifier = 'without' | 'with' | 'inherited'; +export type ApexMethodModifier = 'static' | 'final' | 'webservice' | 'override' | 'testmethod'; +export type ApexFieldModifier = 'transient' | 'final' | 'static'; +export type ApexPropertyModifier = 'transient' | 'static'; +export type ApexModifier = ApexAccessModifier | ApexClassModifier | ApexSharingModifier | ApexMethodModifier | ApexFieldModifier; + +export interface ApexSourceLocation { + line: number; + column: number; +} + +export interface ApexSourceRange { + start: ApexSourceLocation; + stop: ApexSourceLocation; +} + +export interface SourceFragment { + sourceRange: ApexSourceRange; +} + +export namespace ApexSourceRange { + export const empty = { start: { line: -1, column: -1 }, stop: { line: -1, column: -1 } }; + + /** + * Get the Range of the tokens to which the specified context refers. + * @param context Context to get the range for + * @returns The range of the tokens to which the specified context refers + */ + export function fromToken(context: { start: Token | null, stop: Token | null }) : ApexSourceRange { + return { + start: { + line: context.start?.line ?? -1, + column: (context.start?.column ?? -2) + 1 + }, + stop: { + line: context.stop?.line ?? -1, + column: (context.stop?.column ?? -3) + 2 + } + }; + } +} + +export interface ApexInterface extends SourceFragment { + name: string; + methods: ApexMethod[]; + properties: ApexProperty[]; + fields: ApexField[]; +} + +export interface ApexClass extends SourceFragment { + name: string; + isTest?: boolean; + isAbstract?: boolean; + isVirtual?: boolean; + methods: ApexMethod[]; + properties: ApexProperty[]; + fields: ApexField[]; + implements: ApexTypeRef[]; + access?: ApexAccessModifier; + type?: ApexClassModifier; + sharing?: ApexSharingModifier; + extends?: ApexTypeRef; + nested: ApexClass[]; + refs: ApexTypeRef[]; +} + +export interface ApexMethod extends ApexBlock { + name: string; + isTest?: boolean; + isAbstract?: boolean; + isVirtual?: boolean; + returnType: ApexTypeRef; + parameters: ApexMethodParameter[]; + access?: ApexAccessModifier; + modifiers: ApexMethodModifier[]; + decorators: string[]; + localVariables: ApexLocalVariable[]; + refs: ApexTypeRef[]; // References to other things +} + +export interface ApexLocalVariable extends SourceFragment { + name: string; + type: ApexTypeRef; +} + +export interface ApexBlock extends SourceFragment { + localVariables?: ApexLocalVariable[]; + refs?: ApexTypeRef[]; // References to other things + blocks?: ApexBlock[]; +} + +export interface ApexProperty extends SourceFragment { + name: string; + type: ApexTypeRef; + getter?: ApexBlock, + setter?: ApexBlock, + isStatic?: boolean; + isTransient?: boolean; + access?: ApexAccessModifier; + modifiers?: ApexFieldModifier[]; +} + +export interface ApexField extends SourceFragment { + name: string | string[]; + type: ApexTypeRef; + isStatic?: boolean; + isFinal?: boolean; + isTransient?: boolean; + access?: ApexAccessModifier; + modifiers?: ApexFieldModifier[]; +} + +export type ApexTypeRefSource = + 'new' | + 'extends' | + 'implements' | + 'field' | + 'parameter' | + 'classVariable' | + 'localVariable' | + 'property' | + 'identifier'; + +export interface ApexTypeRef { + namespace?: string; + name: string; + genericArguments?: ApexTypeRef[]; + isSystemType: boolean; + source?: ApexTypeRefSource; +} + +export namespace ApexTypeRef { + + const primitiveTypes: readonly string[] = [ + 'string', + 'boolean', + 'integer', + 'decimal', + 'long', + 'double', + 'date', + 'datetime', + 'time', + 'id' + ]; + + const systemTypes: readonly string[] = [ + 'map', + 'set', + 'list', + 'void', + 'object', + 'sobject', + 'blob' + ]; + + const standardNamespaces: readonly string[] = stdNamespaceData.map((namespace: string) => namespace.toLowerCase()); + + export function fromString(name: string, source?: ApexTypeRefSource): ApexTypeRef { + return { name, isSystemType: isSystemType(name), source }; + } + + export function isPrimitiveType(typeName: string): boolean { + return systemTypes.includes(typeName.toLowerCase()) || + primitiveTypes.includes(typeName.toLowerCase()); + } + + export function isSystemType(typeName: string): boolean { + return systemTypes.includes(typeName.toLowerCase()) || + primitiveTypes.includes(typeName.toLowerCase()); + } + + export function isStandardNamespace(ns: string): boolean { + return standardNamespaces.includes(ns.split('.').shift()!.toLowerCase()); + } +} + +export interface ApexMethodParameter { + name: string; + type: ApexTypeRef; +} + +export interface ApexCompilationUnit { + classes: ApexClass[]; + interfaces: ApexInterface[]; +} \ No newline at end of file diff --git a/packages/apex/src/visitors/blockVisitor.ts b/packages/apex/src/visitors/blockVisitor.ts new file mode 100644 index 00000000..b4d955c2 --- /dev/null +++ b/packages/apex/src/visitors/blockVisitor.ts @@ -0,0 +1,137 @@ +import { ApexBlock, ApexClass, ApexSourceRange, ApexTypeRef } from "../types"; +import { TypeRefVisitor } from "./typeRefVisitor"; +import { DeclarationVisitor } from "./declarationVisitor"; +import { BlockContext, CatchClauseContext, DotExpressionContext, IdCreatedNamePairContext, IdPrimaryContext, LocalVariableDeclarationContext } from "../grammar"; +import { TypeListVisitor } from "./typeListVisitor"; +import { stringEquals, substringBefore } from "@vlocode/util"; +import standardNamespaces from '../standardNamespace.json'; + +export class BlockVisitor extends DeclarationVisitor { + + private static standardNamespaces = standardNamespaces.map((namespace: string) => namespace.toLowerCase()); + + constructor(state: T) { + super(state); + } + + private addBlock(block: ApexBlock) { + if (!this.state.blocks) { + this.state.blocks = []; + } + this.state.blocks.push(block); + } + + public visitBlock(ctx: BlockContext) { + this.addBlock( + new BlockVisitor({ + sourceRange: ApexSourceRange.fromToken(ctx) + }).visitChildren(ctx) + ); + return this.state; + } + + public visitLocalVariableDeclaration(ctx: LocalVariableDeclarationContext) { + for (const variableDeclarator of ctx.variableDeclarators()?.variableDeclarator() ?? []) { + const variableType = ctx.typeRef().accept(new TypeRefVisitor())!; + this.addLocalVariable( + variableDeclarator.id().getText(), + variableType, + ApexSourceRange.fromToken(variableDeclarator) + ); + variableDeclarator.expression()?.accept(this); + } + return this.state; + } + + // public visitAssignExpression(ctx: AssignExpressionContext) { + // ctx.expression().slice(1).forEach(expr => this.visit(expr)); + // return this.visit + // } + + public visitCatchClause(ctx: CatchClauseContext) { + this.addLocalVariable( + ctx.id().getText(), + ApexTypeRef.fromString(ctx.qualifiedName().getText()), + ApexSourceRange.fromToken(ctx.id()) + ); + this.visitBlock(ctx.block()); + return this.state; + } + + public visitDotExpression(ctx: DotExpressionContext) { + if (ctx.anyId() && + ctx.parent instanceof DotExpressionContext && + ctx.expression().getChild(0) instanceof IdPrimaryContext && + ApexTypeRef.isStandardNamespace(ctx.getText()) + ) { + this.addRef( + ApexTypeRef.fromString(ctx.getText()), + 'identifier' + ) + return this.state; + } + return this.visitChildren(ctx); + } + + public visitIdPrimary(ctx: IdPrimaryContext) { + const id = ctx.getText(); + const isLocal = this.state.localVariables?.some(v => v.name === id); + if (!isLocal) { + this.addRef( + ApexTypeRef.fromString(ctx.getText()), + 'identifier' + ); + } + return this.visitChildren(ctx); + } + + public visitIdCreatedNamePair(ctx: IdCreatedNamePairContext) { + const typeList = ctx.typeList(); + this.addRef({ + ...ApexTypeRef.fromString(ctx.anyId().getText()), + genericArguments: (typeList && new TypeListVisitor().visit(typeList)) ?? undefined + }, 'new'); + return this.visitChildren(ctx); + } + + public addLocalVariable(name: string, type: ApexTypeRef, sourceRange: ApexSourceRange) { + if (!this.state.localVariables) { + this.state.localVariables = []; + } + this.state.localVariables.push({ name, type, sourceRange }); + this.addRef(type, 'localVariable'); + } + + protected getLocalVariableNames(blockHierarchy: ApexBlock[]) { + return blockHierarchy.flatMap(block => block.localVariables ?? []).map(v => v.name); + } + + public updateReferences(context: ApexClass) { + const classVariables = context.fields.flatMap(f => f.name).concat(context.properties.map(p => p.name)); + for (const blockHierarchy of this.resolveBlockHierarchy()) { + const blockLeaf = blockHierarchy[blockHierarchy.length - 1]; + if (!blockLeaf.refs) { + continue; + } + + const blockLocalVariables = blockHierarchy.flatMap(block => block.localVariables ?? []).map(v => v.name).concat(classVariables); + blockLeaf.refs = blockLeaf.refs.filter(ref => { + if (ref.source !== 'identifier') { + return true; + } + const localName = ref.name.split('.').shift(); + return !blockLocalVariables.some(localVar => stringEquals(localVar, localName, { caseInsensitive: true })); + }); + this.addRef(blockLeaf.refs); + } + } + + public *resolveBlockHierarchy() : Generator { + yield [ this.state ]; + for (const block of this.state.blocks ?? []) { + for (const blocks of new BlockVisitor(block).resolveBlockHierarchy()) { + yield [ this.state, ...blocks ]; + } + } + } +} \ No newline at end of file diff --git a/packages/apex/src/visitors/classDeclarationVisitor.ts b/packages/apex/src/visitors/classDeclarationVisitor.ts new file mode 100644 index 00000000..0b98be28 --- /dev/null +++ b/packages/apex/src/visitors/classDeclarationVisitor.ts @@ -0,0 +1,168 @@ +import { ApexClass, ApexSourceRange } from "../types"; +import { MethodDeclarationVisitor } from "./methodDeclarationVisitor"; +import { TypeRefVisitor } from "./typeRefVisitor"; +import { DeclarationVisitor } from "./declarationVisitor"; +import { FieldDeclarationVisitor } from "./fieldDeclarationVisitor"; +import { AnnotationContext, ClassBodyContext, ClassBodyDeclarationContext, ClassDeclarationContext, FieldDeclarationContext, MemberDeclarationContext, MethodDeclarationContext, ModifierContext, PropertyDeclarationContext } from "../grammar"; +import { PropertyDeclarationVisitor } from "./propertyDeclarationVisitor"; +import { BlockVisitor } from "./blockVisitor"; + +export class ClassDeclarationVisitor extends DeclarationVisitor { + constructor(state?: ApexClass) { + super(state ?? { + name: '', + methods: [], + properties: [], + fields: [], + implements: [], + extends: undefined, + nested: [], + refs: [], + sourceRange: ApexSourceRange.empty, + }); + } + + public visitAnnotation(ctx: AnnotationContext | null): ApexClass { + if (ctx?.qualifiedName().getText().toLocaleLowerCase() === 'istest') { + this.state.isTest = true; + } + return this.state; + } + + public visitModifier(ctx: ModifierContext) { + if (ctx.ABSTRACT()) { + this.state.isAbstract = true; + } + if (ctx.VIRTUAL()) { + this.state.isVirtual = true; + } + this.visitAnnotation(ctx.annotation()); + this.visitAccessModifier(ctx) || this.visitSharingModifier(ctx); + return this.state; + } + + private visitSharingModifier(ctx: ModifierContext): boolean { + if (ctx.WITH()) { + this.state.sharing = 'with'; + } else if (ctx.WITHOUT()) { + this.state.sharing = 'without'; + } else if (ctx.INHERITED()) { + this.state.sharing = 'inherited'; + } else if (!ctx.SHARING()) { + return false; + } + return true; + } + + public visitClassDeclaration(ctx: ClassDeclarationContext): ApexClass { + this.state.name = ctx.id().getText(); + + if (ctx.EXTENDS()) { + // Parse `extends XXX` + const extendedType = ctx.typeRef()?.accept(new TypeRefVisitor()); + if (extendedType) { + this.state.extends = extendedType; + this.addRef(extendedType, 'extends'); + } + } + + if (ctx.IMPLEMENTS()) { + // Parse `implements XXX, YYY` + this.state.implements = ctx.typeList()?.typeRef().map(typeRef => new TypeRefVisitor().visit(typeRef)!) ?? []; + this.addRef(this.state.implements, 'implements'); + } + + ctx.classBody().accept(this); + return this.state; + } + + public visitClassBody(ctx: ClassBodyContext): ApexClass { + // Parse all the fields and properties first so that we know which are locals + new FieldAndPropertyDeclarationVisitor(this.state).visitChildren(ctx); + // Now visit all members using this visitor + this.visitChildren(ctx); + // Update references for all methods and properties + this.updateReferences(); + return this.state; + } + + public visitClassBodyDeclaration(ctx: ClassBodyDeclarationContext) { + ctx.memberDeclaration()?.accept(this); + return this.state; + } + + public visitMemberDeclaration(ctx: MemberDeclarationContext) { + const classDeclaration = ctx.classDeclaration(); + if (classDeclaration) { + const nestedClass = new ClassDeclarationVisitor().visit(classDeclaration); + if (nestedClass) { + nestedClass.sourceRange = ApexSourceRange.fromToken(classDeclaration); + this.addRef(nestedClass.refs); + this.state.nested.push(nestedClass); + } + return this.state; + } + return this.visitChildren(ctx); + } + + public visitMethodDeclaration(ctx: MethodDeclarationContext) { + const memberContext = ctx.parent?.parent; + if (memberContext) { + const visitor = new MethodDeclarationVisitor(); + const method = visitor.visit(memberContext); + if (method) { + // Remove references to local variables and properties + visitor.updateReferences(this.state); + method.sourceRange = ApexSourceRange.fromToken(memberContext); + this.addRef(method.returnType); + this.addRef(method.refs); + this.state.methods.push(method); + } + } + return this.state; + } + + public updateReferences() { + for (const property of this.state.properties) { + if (property.getter) { + new BlockVisitor(property.getter).updateReferences(this.state); + this.addRef(property.getter?.refs); + } + if (property.setter) { + new BlockVisitor(property.setter).updateReferences(this.state); + this.addRef(property.setter?.refs); + } + } + } +} + +class FieldAndPropertyDeclarationVisitor extends DeclarationVisitor { + constructor(state: ApexClass) { + super(state); + } + + public visitPropertyDeclaration(ctx: PropertyDeclarationContext): ApexClass { + const memberContext = ctx.parent?.parent; + if (memberContext) { + const property = new PropertyDeclarationVisitor().visit(memberContext); + if (property) { + property.sourceRange = ApexSourceRange.fromToken(memberContext); + this.addRef(property.type, 'property'); + this.state.properties.push(property); + } + } + return this.state; + } + + public visitFieldDeclaration(ctx: FieldDeclarationContext) { + const memberContext = ctx.parent?.parent; + if (memberContext) { + const field = new FieldDeclarationVisitor().visit(memberContext); + if (field) { + this.addRef(field.type, 'field'); + this.state.fields.push(field); + } + } + return this.state; + } +} \ No newline at end of file diff --git a/packages/apex/src/visitors/compilationUnitVisitor.ts b/packages/apex/src/visitors/compilationUnitVisitor.ts new file mode 100644 index 00000000..286710b6 --- /dev/null +++ b/packages/apex/src/visitors/compilationUnitVisitor.ts @@ -0,0 +1,35 @@ +import { ApexSyntaxTreeVisitor } from "./syntaxTreeVisitor"; +import { ClassDeclarationVisitor } from "./classDeclarationVisitor"; +import { ApexClass, ApexCompilationUnit, ApexSourceRange } from "../types"; +import { TypeDeclarationContext } from "../grammar"; + +export class CompilationUnitVisitor extends ApexSyntaxTreeVisitor { + constructor(state?: ApexCompilationUnit) { + super(state ?? { classes: [], interfaces: [] }); + } + + public visitTypeDeclaration(ctx: TypeDeclarationContext) { + if (ctx.classDeclaration()) { + const classInfo = new ClassDeclarationVisitor().visit(ctx); + if (classInfo) { + classInfo.sourceRange = ApexSourceRange.fromToken(ctx); + this.addClass(classInfo); + } + } + return this.state; + } + + private addClass(classInfo: ApexClass) { + this.state.classes.push(classInfo); + + // add nested classes to the top level + if (classInfo.nested.length) { + this.state.classes.push( + ...classInfo.nested.map(nested => ({ + ...nested, + name: `${classInfo.name}.${nested.name}` + })) + ); + } + } +} diff --git a/packages/apex/src/visitors/declarationVisitor.ts b/packages/apex/src/visitors/declarationVisitor.ts new file mode 100644 index 00000000..9cb9d200 --- /dev/null +++ b/packages/apex/src/visitors/declarationVisitor.ts @@ -0,0 +1,61 @@ +import { stringEquals } from "@vlocode/util"; +import { ModifierContext } from "../grammar"; +import { ApexAccessModifier, ApexTypeRef, ApexTypeRefSource } from "../types"; +import { ApexSyntaxTreeVisitor } from "./syntaxTreeVisitor"; + +export abstract class DeclarationVisitor extends ApexSyntaxTreeVisitor { + constructor(state: T) { + super(state); + } + + public visitModifier(ctx: ModifierContext) { + this.addModifier(ctx.getText().toLowerCase()); + this.visitAccessModifier(ctx); + return this.state; + } + + protected addModifier(modifier: string) { + if (!this.state.modifiers) { + this.state.modifiers = []; + } + this.state.modifiers.push(modifier); + } + + protected visitAccessModifier(ctx: ModifierContext): boolean { + if (ctx.PUBLIC()) { + this.state.access = 'public'; + } else if (ctx.PROTECTED()) { + this.state.access = 'protected'; + } else if (ctx.GLOBAL()) { + this.state.access = 'global'; + } else if (ctx.PRIVATE()) { + this.state.access = 'private'; + } else { + return false; + } + return true; + } + + protected addRef(refs: ApexTypeRef | ApexTypeRef[] | undefined | null, source?: ApexTypeRefSource) { + if (refs === undefined || refs === null) { + return; + } + + if (!this.state.refs) { + this.state.refs = []; + } + + for (const ref of Array.isArray(refs) ? refs : [ refs ]) { + if (ref.name === 'void') { + continue; + } + if (!this.state.refs.find(r => (source === undefined || r.source === source) && stringEquals(r.name, ref.name, { caseInsensitive: true}))) { + this.state.refs.push({ ...ref, source: source ?? ref.source }); + } + } + } +} \ No newline at end of file diff --git a/packages/apex/src/visitors/fieldDeclarationVisitor.ts b/packages/apex/src/visitors/fieldDeclarationVisitor.ts new file mode 100644 index 00000000..3e62acb9 --- /dev/null +++ b/packages/apex/src/visitors/fieldDeclarationVisitor.ts @@ -0,0 +1,59 @@ +import { ModifierContext, TypeRefContext, VariableDeclaratorContext } from "../grammar"; +import { ApexField, ApexSourceRange } from "../types"; +import { DeclarationVisitor } from "./declarationVisitor"; +import { TypeRefVisitor } from "./typeRefVisitor"; + +/** + * Represents a visitor for field declarations in Apex. + */ +export class FieldDeclarationVisitor extends DeclarationVisitor { + + constructor(state?: ApexField) { + super(state ?? { + name: '', + type: { + name: '', + isSystemType: false, + source: 'field' + }, + sourceRange: ApexSourceRange.empty, + }); + } + + public visitModifier(ctx: ModifierContext) { + this.visitAccessModifier(ctx) || this.visitFieldModifiers(ctx); + return this.state; + } + + public visitFieldModifiers(ctx: ModifierContext) { + if (ctx.STATIC()) { + this.state.isStatic = true; + } else if (ctx.FINAL()) { + this.state.isFinal = true; + } else if (ctx.TRANSIENT()) { + this.state.isTransient = true; + } else { + return false; + } + return true; + } + + public visitVariableDeclarator(ctx: VariableDeclaratorContext) { + const name = ctx.id().getText(); + if (this.state.name) { + if (!Array.isArray(this.state.name)) { + this.state.name = [ this.state.name, name ]; + } else { + this.state.name.push(name); + } + } else { + this.state.name = name; + } + return this.state; + } + + public visitTypeRef(ctx: TypeRefContext) { + new TypeRefVisitor(this.state.type).visit(ctx)!; + return this.state; + } +} \ No newline at end of file diff --git a/packages/apex/src/visitors/formalParameterVisitor.ts b/packages/apex/src/visitors/formalParameterVisitor.ts new file mode 100644 index 00000000..407a12cc --- /dev/null +++ b/packages/apex/src/visitors/formalParameterVisitor.ts @@ -0,0 +1,27 @@ +import { FormalParameterContext, IdContext } from "../grammar"; +import { ApexMethodParameter } from "../types"; +import { ApexSyntaxTreeVisitor } from "./syntaxTreeVisitor"; +import { TypeRefVisitor } from "./typeRefVisitor"; + +export class FormalParameterVisitor extends ApexSyntaxTreeVisitor { + constructor(state?: ApexMethodParameter) { + super(state ?? { + name: '', + type: { + name: '', + isSystemType: false + } + }); + } + + public visitFormalParameter(ctx: FormalParameterContext): ApexMethodParameter { + ctx.id().accept(this); + ctx.typeRef().accept(new TypeRefVisitor(this.state.type)); + return this.state; + } + + public visitId(ctx: IdContext) { + this.state.name = ctx.getText(); + return this.state; + } +} \ No newline at end of file diff --git a/packages/apex/src/visitors/methodDeclarationVisitor.ts b/packages/apex/src/visitors/methodDeclarationVisitor.ts new file mode 100644 index 00000000..3ef99558 --- /dev/null +++ b/packages/apex/src/visitors/methodDeclarationVisitor.ts @@ -0,0 +1,71 @@ +import { ApexMethod, ApexMethodModifier, ApexSourceRange, ApexTypeRef } from "../types"; +import { FormalParameterVisitor } from "./formalParameterVisitor"; +import { TypeRefVisitor } from "./typeRefVisitor"; +import { AnnotationContext, BlockContext, FormalParametersContext, MethodDeclarationContext, ModifierContext } from "../grammar"; +import { BlockVisitor } from "./blockVisitor"; + +export class MethodDeclarationVisitor extends BlockVisitor { + constructor(state?: ApexMethod) { + super(state ?? { + name: '', + returnType: { + name: '', + isSystemType: false + }, + modifiers: [], + parameters: [], + decorators: [], + localVariables: [], + refs: [], + sourceRange: ApexSourceRange.empty, + }); + } + + public visitBlock(ctx: BlockContext) { + return new BlockVisitor(this.state).visitChildren(ctx); + } + + public visitAnnotation(ctx: AnnotationContext | null): ApexMethod { + if (ctx?.qualifiedName().getText().toLowerCase() === 'istest') { + this.state.isTest = true; + } + return this.state; + } + + public visitModifier(ctx: ModifierContext) { + if (ctx.TESTMETHOD()) { + this.state.isTest = true; + } + if (ctx.ABSTRACT()) { + this.state.isAbstract = true; + } + if (ctx.VIRTUAL()) { + this.state.isVirtual = true; + } + if (!this.visitAccessModifier(ctx)) { + this.state.modifiers.push(ctx.getText() as ApexMethodModifier); + } + this.visitAnnotation(ctx.annotation()); + return this.state; + } + + public visitMethodDeclaration(ctx: MethodDeclarationContext) { + this.state.name = ctx.id().getText(); + ctx.formalParameters().accept(this); + ctx.block()?.accept(this); + if (ctx.VOID()) { + this.state.returnType = ApexTypeRef.fromString('void'); + } else { + ctx.typeRef()?.accept(new TypeRefVisitor(this.state.returnType)); + } + return this.state; + } + + public visitFormalParameters(ctx: FormalParametersContext) { + ctx.formalParameterList()?.formalParameter().forEach(parameter => { + this.state.parameters.push(parameter.accept(new FormalParameterVisitor())!); + }); + this.addRef(this.state.parameters.map(p => p.type), 'parameter'); + return this.state; + } +} \ No newline at end of file diff --git a/packages/apex/src/visitors/propertyDeclarationVisitor.ts b/packages/apex/src/visitors/propertyDeclarationVisitor.ts new file mode 100644 index 00000000..113bc524 --- /dev/null +++ b/packages/apex/src/visitors/propertyDeclarationVisitor.ts @@ -0,0 +1,86 @@ +import { GetterContext, ModifierContext, PropertyDeclarationContext, SetterContext, TypeRefContext } from "../grammar"; +import { ApexSourceRange, ApexProperty, ApexPropertyModifier, ApexBlock, ApexTypeRef } from "../types"; +import { BlockVisitor } from "./blockVisitor"; +import { DeclarationVisitor } from "./declarationVisitor"; +import { TypeRefVisitor } from "./typeRefVisitor"; + +/** + * Represents a visitor for field declarations in Apex. + */ +export class PropertyDeclarationVisitor extends DeclarationVisitor { + + constructor(state?: ApexProperty) { + super(state ?? { + name: '', + type: { + name: '', + isSystemType: false + }, + sourceRange: ApexSourceRange.empty, + }); + } + + public visitModifier(ctx: ModifierContext) { + if (!this.visitAccessModifier(ctx) && !this.visitPropertyModifiers(ctx)) { + if (!this.state.modifiers) { + this.state.modifiers = []; + } + this.state.modifiers.push(ctx.getText() as ApexPropertyModifier); + } + return this.state; + } + + public visitPropertyModifiers(ctx: ModifierContext) { + if (ctx.STATIC()) { + this.state.isStatic = true; + } else if (ctx.TRANSIENT()) { + this.state.isTransient = true; + } else { + return false; + } + return true; + } + + public visitPropertyDeclaration(ctx: PropertyDeclarationContext): ApexProperty { + this.state.name = ctx.id().getText(); + return this.visitChildren(ctx); + } + + public visitTypeRef(ctx: TypeRefContext) { + this.state.type = new TypeRefVisitor().visit(ctx) ?? this.state.type; + return this.state; + } + + public visitGetter(ctx: GetterContext): ApexProperty { + const getterBlock = ctx.block(); + if (getterBlock) { + const visitor = new BlockVisitor({ + sourceRange: ApexSourceRange.fromToken(getterBlock), + }); + this.state.getter = visitor.visitChildren(getterBlock); + } + return this.state; + } + + public visitSetter(ctx: SetterContext): ApexProperty { + const setterBlock = ctx.block(); + if (setterBlock) { + const visitor = new SetterBlockVisitor(this.state.type, ApexSourceRange.fromToken(setterBlock)); + this.state.setter = setterBlock.accept(visitor)!; + } + return this.state; + } +} + +class SetterBlockVisitor extends BlockVisitor { + constructor(type: ApexTypeRef, sourceRange: ApexSourceRange) { + super({ + sourceRange, + localVariables: [{ + name: 'value', + type, + sourceRange: ApexSourceRange.empty + }] + }); + } +} \ No newline at end of file diff --git a/packages/apex/src/visitors/syntaxTreeVisitor.ts b/packages/apex/src/visitors/syntaxTreeVisitor.ts new file mode 100644 index 00000000..c810dd8e --- /dev/null +++ b/packages/apex/src/visitors/syntaxTreeVisitor.ts @@ -0,0 +1,62 @@ +import { ParserRuleContext } from "antlr4ng"; +import { ApexParserVisitor } from "../grammar"; +import "../grammar"; + +export abstract class ApexSyntaxTreeVisitor extends ApexParserVisitor { + constructor(protected state: T) { + super(); + } + + public visitChildren(node: ParserRuleContext): T { + const result = super.visitChildren(node); + if (Array.isArray(result)) { + for (const childResult of result) { + this.aggregateResult(this.state, childResult); + } + } + return this.state; + } + + /** + * Aggregates the result of a child node into the state of the visitor. + * This method is called by `visitChildren` for each child node. + * @param aggregate The current state of the visitor + * @param nextResult The result of the child node + * @returns The new state of the visitor + */ + protected aggregateResult(aggregate: T, nextResult: T): T { // eslint-disable-line @typescript-eslint/no-unused-vars + return this.state; + } + + /** + * Get the first child of a node of a specific type + * @param node Node to get the child from + * @param type Type of the child to get + * @returns The first child of the specified type or throws an error if no child of the specified type was found + */ + public getFirstChildOfType(node: ParserRuleContext, type: new (...args: any[]) => TNode): TNode { + for (const child of node.children ?? []) { + if (child instanceof type) { + return child; + } + } + throw new Error(`Expected child node of type: ${type.name}`); + } + + /** + * Get all sibling nodes ao the same level as the specified node of a specific type. + * Checks the parent node of the specified node. + * @param node Node to get the siblings from + * @param type Type of the siblings to get + * @returns All sibling nodes of the specified type or an empty array if no siblings of the specified type were found + */ + public getSiblingsOfType(node: ParserRuleContext, type: new (...args: any[]) => TNode): TNode[] { + const siblings: TNode[] = []; + for (const child of node.parent?.children ?? []) { + if (child instanceof type) { + siblings.push(child); + } + } + return siblings; + } +} diff --git a/packages/apex/src/visitors/typeListVisitor.ts b/packages/apex/src/visitors/typeListVisitor.ts new file mode 100644 index 00000000..177d2efb --- /dev/null +++ b/packages/apex/src/visitors/typeListVisitor.ts @@ -0,0 +1,15 @@ +import { TypeRefContext } from "../grammar"; +import { ApexTypeRef } from "../types"; +import { ApexSyntaxTreeVisitor } from "./syntaxTreeVisitor"; +import { TypeRefVisitor } from "./typeRefVisitor"; + +export class TypeListVisitor extends ApexSyntaxTreeVisitor { + constructor(state?: ApexTypeRef[]) { + super(state ?? []); + } + + public visitTypeRef(ctx: TypeRefContext) { + this.state.push(new TypeRefVisitor().visit(ctx) as ApexTypeRef); + return this.state; + } +} \ No newline at end of file diff --git a/packages/apex/src/visitors/typeRefCollector.ts b/packages/apex/src/visitors/typeRefCollector.ts new file mode 100644 index 00000000..85bd20ca --- /dev/null +++ b/packages/apex/src/visitors/typeRefCollector.ts @@ -0,0 +1,59 @@ +import { IdCreatedNamePairContext, IdPrimaryContext, TypeNameContext } from "../grammar"; +import { ApexTypeRef } from "../types"; +import { ApexSyntaxTreeVisitor } from "./syntaxTreeVisitor"; +import { TypeListVisitor } from "./typeListVisitor"; +import { TypeRefVisitor } from "./typeRefVisitor"; + +/** + * Collects all type references in a given Apex syntax tree and returns them as an array of unique `ApexTypeRef` objects that are referenced in the tree. + * Useful for getting all external types referenced in a given Apex syntax tree. + */ +export class TypeRefCollector extends ApexSyntaxTreeVisitor { + private distinctTypes = new Set(); + + constructor(private options?: { excludeSystemTypes?: boolean }) { + super([]); + } + + + public visitIdCreatedNamePair(ctx: IdCreatedNamePairContext) { + const typeRef = { + name: ctx.anyId().getText(), + isSystemType: ApexTypeRef.isSystemType(ctx.getText()), + genericArguments: (ctx.typeList() && new TypeListVisitor().visit(ctx.typeList()!)) ?? undefined + }; + this.addDistinct(typeRef); + return this.state; + } + + public visitIdPrimary(ctx: IdPrimaryContext) { + const name = ctx.getText(); + this.addDistinct({ name, isSystemType: ApexTypeRef.isSystemType(name) }); + return this.visitChildren(ctx); + } + + public visitTypeName(ctx: TypeNameContext) { + this.addDistinct(new TypeRefVisitor().visit(ctx)); + return this.state; + } + + private addDistinct(typeRef: ApexTypeRef | null) { + if (!typeRef) { + return; + } + + if (!this.options?.excludeSystemTypes || !typeRef.isSystemType) { + const typeName = `${typeRef.name}`; + if (!this.distinctTypes.has(typeName)) { + this.distinctTypes.add(typeName); + this.state.push(typeRef); + } + } + + if (typeRef.genericArguments && typeRef.genericArguments.length > 0) { + for (const genericArgument of typeRef.genericArguments) { + this.addDistinct(genericArgument); + } + } + } +} \ No newline at end of file diff --git a/packages/apex/src/visitors/typeRefVisitor.ts b/packages/apex/src/visitors/typeRefVisitor.ts new file mode 100644 index 00000000..23a1841a --- /dev/null +++ b/packages/apex/src/visitors/typeRefVisitor.ts @@ -0,0 +1,22 @@ +import { TerminalNode } from "antlr4ng"; +import { TypeArgumentsContext } from "../grammar"; +import { ApexTypeRef } from "../types"; +import { ApexSyntaxTreeVisitor } from "./syntaxTreeVisitor"; +import { TypeListVisitor } from "./typeListVisitor"; + +export class TypeRefVisitor extends ApexSyntaxTreeVisitor { + constructor(state: Partial = {}) { + super(state as ApexTypeRef); + } + + public visitTypeArguments(ctx: TypeArgumentsContext) { + this.state.genericArguments = (ctx.typeList() && new TypeListVisitor().visit(ctx.typeList()!)) ?? undefined; + return this.state; + } + + public visitTerminal(node: TerminalNode) { + this.state.name = node.getText(); + this.state.isSystemType = ApexTypeRef.isSystemType(this.state.name); + return this.state; + } +} \ No newline at end of file diff --git a/packages/apex/tsconfig.json b/packages/apex/tsconfig.json new file mode 100644 index 00000000..21816f2f --- /dev/null +++ b/packages/apex/tsconfig.json @@ -0,0 +1,13 @@ +{ + "extends": "../../tsconfig", + "compilerOptions": { + "composite": true, + "outDir": "lib", + "rootDir": "src", + "declaration": true, + "declarationMap": true, + "skipLibCheck": true + }, + "include": ["src/**/*.ts", "src/**/*.json"], + "references": [{ "path": "../util" }, { "path": "../core" }] +} diff --git a/packages/cli/package.json b/packages/cli/package.json index 04e7f21d..226d234c 100644 --- a/packages/cli/package.json +++ b/packages/cli/package.json @@ -55,6 +55,7 @@ "devDependencies": { "@types/jest": "^29.5.11", "@types/node": "^20.4.2", + "@vlocode/apex": "workspace:*", "@vlocode/core": "workspace:*", "@vlocode/omniscript": "workspace:*", "@vlocode/salesforce": "workspace:*", @@ -62,7 +63,7 @@ "@vlocode/vlocity": "workspace:*", "@vlocode/vlocity-deploy": "workspace:*", "chalk": "^4.1.1", - "commander": "^9.2.0", + "commander": "^11.1.0", "esbuild-loader": "^4.0.3", "glob": "^7.1.7", "jest": "^29.7.0", diff --git a/packages/cli/src/commands/impactedTests.ts b/packages/cli/src/commands/impactedTests.ts new file mode 100644 index 00000000..27741927 --- /dev/null +++ b/packages/cli/src/commands/impactedTests.ts @@ -0,0 +1,135 @@ +import { Logger, LogManager, FileSystem, injectable } from '@vlocode/core'; +import { Timer, stringEqualsIgnoreCase, unique } from '@vlocode/util'; +import { existsSync} from 'fs-extra'; +import path from 'path'; +import chalk from 'chalk'; + +import { Parser } from '@vlocode/apex'; +import { Argument, Option, Command } from '../command'; + +interface ApexClassInfo { + name: string, + file: string, + isAbstract: boolean, + isTest: boolean, + refs: string[], + testClasses?: string[] +} + +@injectable() +export default class extends Command { + + static description = 'Find impacted unit tests for a given set of APEX classes'; + + static args = [ + new Argument('', 'path to a folder containing the APEX classes files and triggers to parse') + .argParser((value, previous: string[] | undefined) => { + if (!existsSync(value)) { + throw new Error('No such folder exists'); + } + return (previous ?? []).concat([ value ]); + }).argRequired() + ]; + + static options = [ + new Option('--classes ', 'list of classes to find impacted tests for'), + new Option('--output ', 'path to the file to which to write the impacted tested output as JSON').default('impactedTests.json') + ]; + + constructor( + private fileSystem: FileSystem, + private logger: Logger = LogManager.get('vlocode-cli') + ) { + super(); + } + + public async run(folders: string[], options: { classes?: string[] }) { + const timerAll = new Timer(); + + const data = await this.parseSourceFiles(folders); + const testClasses = Object.values(data).filter((info) => info.isTest); + + this.logger.info(`Parsed ${Object.keys(data).length} in ${timerAll.toString('ms')}`); + this.logger.info(`Found ${testClasses.length} test classes`); + + for (const classInfo of Object.values(data)) { + if (classInfo.isTest) { + continue; + } + + const directTestClasses = testClasses.filter(testClass => + testClass.refs.some(ref => stringEqualsIgnoreCase(ref, classInfo.name)) + ); + const indirectTestClasses = testClasses.filter(testClass => + testClass.refs.some(ref => { + const refInfo = data[ref.toLowerCase()]; + return refInfo && refInfo.refs.some(ref => stringEqualsIgnoreCase(ref, classInfo.name)); + }) + ); + + classInfo.testClasses = [ + ...directTestClasses, + ...indirectTestClasses + ].map(testClass => testClass.name); + } + + for (const className of options.classes ?? []) { + const classInfo = data[className.toLowerCase()]; + if (!classInfo) { + this.logger.error(`Class ${className} not found`); + continue; + } + + this.logger.info(`Class ${chalk.bold(classInfo.name)} is referenced by ${chalk.bold(classInfo.testClasses?.length ?? 0)} test classes`); + if (classInfo.testClasses?.length) { + this.logger.info(`Test classes: ${classInfo.testClasses.join(', ')}`); + } + } + this.logger.info(`Write impacted tests to impactedTests.json`); + await this.fileSystem.writeFile('impactedTests.json', Buffer.from(JSON.stringify(data, null, 4))); + this.logger.info(`Parsed ${Object.keys(data).length} in ${timerAll.toString('ms')}`); + } + + private async parseSourceFiles(folders: string[]) { + const data: Record = {}; + + for (const folder of folders) { + for await (const { buffer, file } of this.readSourceFiles(folder)) { + const parseTimer = new Timer(); + const parser = new Parser(buffer); + const struct = parser.getCodeStructure(); + + for (const classInfo of struct.classes) { + //const refs = parser.getReferencedTypes({ excludeSystemTypes: true }); + data[classInfo.name.toLowerCase()] = { + name: classInfo.name, + file, + isAbstract: !!classInfo.isAbstract, + isTest: !!classInfo.isTest, + refs: [...unique(classInfo.refs, ref => ref.name.toLowerCase(), ref => ref.name)] + }; + } + + this.logger.info(`Parsed ${file} in ${parseTimer.toString('ms')}`); + } + } + + return data; + } + + private async* readSourceFiles(folder: string){ + for (const file of await this.fileSystem.readDirectory(folder)) { + const fullPath = path.join(folder, file.name); + if (file.isDirectory()) { + yield* this.readSourceFiles(fullPath); + } + if (file.isFile() && file.name.endsWith('.cls') || file.name.endsWith('.trigger')) { + yield { + buffer: await this.fileSystem.readFile(fullPath), + fullPath, + file: file.name + }; + } + } + } +} diff --git a/packages/cli/src/index.ts b/packages/cli/src/index.ts index 1bb6f440..64466c50 100644 --- a/packages/cli/src/index.ts +++ b/packages/cli/src/index.ts @@ -1,7 +1,7 @@ import { readdirSync, readFileSync } from 'fs'; import * as path from 'path'; -import { Command as Commander, Option } from 'commander'; +import { Command, Option } from 'commander'; import { FancyConsoleWriter, container, Logger, LogLevel, LogManager, ConsoleWriter } from '@vlocode/core'; import { getErrorMessage } from '@vlocode/util'; import { Command as CliCommand } from './command'; @@ -25,7 +25,7 @@ class CLI { private static readonly isVerbose = process.argv.includes('-v') || process.argv.includes('--verbose'); private static readonly isDebug = process.argv.includes('--debug'); - private readonly program: Commander; + private readonly program: Command; private readonly logger = LogManager.get(CLI.programName); static readonly options = [ @@ -62,7 +62,7 @@ class CLI { constructor(private commandsFolder: string) { this.logger.verbose(this.versionString); - this.program = new Commander() + this.program = new Command() .name(CLI.programName) .description(CLI.description) .version(`${CLI.version} (${buildInfo.buildDate})`) @@ -114,7 +114,7 @@ class CLI { .toLowerCase(); } - private registerCommand(parentCommand: Commander, commandFile: string) { + private registerCommand(parentCommand: Command, commandFile: string) { try { // @ts-ignore const commandModule = nodeRequire(commandFile); diff --git a/packages/cli/tsconfig.json b/packages/cli/tsconfig.json index 0f9a0efc..b46dc185 100644 --- a/packages/cli/tsconfig.json +++ b/packages/cli/tsconfig.json @@ -10,6 +10,7 @@ "include": ["src/**/*"], "references": [ { "path": "../util" }, + { "path": "../apex" }, { "path": "../core" }, { "path": "../salesforce" }, { "path": "../vlocity" }, diff --git a/packages/salesforce/package.json b/packages/salesforce/package.json index 90fe33cd..34455da1 100644 --- a/packages/salesforce/package.json +++ b/packages/salesforce/package.json @@ -28,7 +28,8 @@ "prepublish": "pnpm run build", "update-registry": "nugget $npm_package_config_metadata/metadataRegistry.json $npm_package_config_metadata/stdValueSetRegistry.json $npm_package_config_metadata/types.ts -q -d ./src/registry", "pre-build": "pnpm update-registry", - "prepare": "pnpm update-registry" + "prepare": "pnpm update-registry", + "build-grammar": "antlr4ng -Dlanguage=TypeScript -o src/apex/grammar -visitor -listener ./grammar/ApexLexer.g4 ./grammar/ApexParser.g4" }, "repository": { "type": "git", @@ -67,6 +68,7 @@ "dependencies": { "@vlocode/core": "workspace:*", "@vlocode/util": "workspace:*", + "antlr4ng": "^2.0.8", "chalk": "^4.1.1", "csv-parse": "^5.3.3", "fs-extra": "^11.0", diff --git a/packages/util/src/__tests__/deferred.test.ts b/packages/util/src/__tests__/deferred.test.ts new file mode 100644 index 00000000..37bb444a --- /dev/null +++ b/packages/util/src/__tests__/deferred.test.ts @@ -0,0 +1,62 @@ +import 'jest'; +import { DeferredPromise } from '../deferred'; + +describe('DeferredPromise', () => { + it('should resolve the promise', async () => { + const deferred = new DeferredPromise(); + setTimeout(() => deferred.resolve(42), 10); + const result = await deferred; + expect(result).toBe(42); + }); + + it('should reject the promise', async () => { + const deferred = new DeferredPromise(); + setTimeout(() => deferred.reject(new Error('Something went wrong'))); + + try { + await deferred; + } catch (error) { + expect(error).toBeInstanceOf(Error); + expect(error.message).toBe('Something went wrong'); + } + }); + + it('should bind to another promise', async () => { + const deferred1 = new DeferredPromise(); + const deferred2 = new DeferredPromise(); + + deferred1.bind(deferred2); + deferred2.resolve(42); + const result = await deferred1; + + expect(result).toBe(42); + }); + + it('should reset the promise', async () => { + const deferred = new DeferredPromise(); + deferred.resolve(42); + deferred.reset(); + expect(deferred.isResolved).toBe(false); + }); + + it('should handle then and catch methods', async () => { + const deferred = new DeferredPromise(); + deferred.resolve(42); + + const result = await deferred.then(value => value * 2).catch(error => -1); + expect(result).toBe(84); + }); + + it('should handle finally method', async () => { + const deferred = new DeferredPromise(); + deferred.resolve(42); + + let finallyCalled = false; + const result = await deferred.finally(() => { + finallyCalled = true; + }); + + expect(result).toBe(42); + expect(finallyCalled).toBe(true); + }); +}); \ No newline at end of file diff --git a/packages/util/src/__tests__/timedMap.test.ts b/packages/util/src/__tests__/timedMap.test.ts new file mode 100644 index 00000000..919a2650 --- /dev/null +++ b/packages/util/src/__tests__/timedMap.test.ts @@ -0,0 +1,133 @@ +import 'jest'; +import { TimedMap } from '../timedMap'; + +describe('TimedMap', () => { + let timedMap: TimedMap; + + beforeEach(() => { + timedMap = new TimedMap({ ttl: 1000, limit: 3 }); + }); + + afterEach(() => { + timedMap.clear(); + }); + + it('should set and get values correctly', () => { + timedMap.set('key1', 1); + timedMap.set('key2', 2); + timedMap.set('key3', 3); + + expect(timedMap.get('key1')).toEqual(1); + expect(timedMap.get('key2')).toEqual(2); + expect(timedMap.get('key3')).toEqual(3); + }); + + it('should update the value and last access timestamp when setting an existing key', () => { + timedMap.set('key1', 1); + timedMap.set('key2', 2); + + timedMap.set('key1', 10); + + expect(timedMap.get('key1')).toEqual(10); + expect(timedMap.get('key2')).toEqual(2); + }); + + it('should delete an entry correctly', () => { + timedMap.set('key1', 1); + timedMap.set('key2', 2); + + const result = timedMap.delete('key1'); + + expect(result).toBe(true); + expect(timedMap.get('key1')).toBeUndefined(); + expect(timedMap.get('key2')).toEqual(2); + }); + + it('should not delete an entry that does not exist', () => { + timedMap.set('key1', 1); + timedMap.set('key2', 2); + + const result = timedMap.delete('key3'); + + expect(result).toBe(false); + expect(timedMap.get('key1')).toEqual(1); + expect(timedMap.get('key2')).toEqual(2); + }); + + it('should perform cleanup of expired entries', () => { + jest.useFakeTimers(); + + timedMap.set('key1', 1); + timedMap.set('key2', 2); + timedMap.set('key3', 3); + + jest.advanceTimersByTime(2000); // Advance time by 2 seconds to expire entries + + timedMap.set('key4', 4); // This should trigger cleanup + + expect(timedMap.get('key1')).toBeUndefined(); + expect(timedMap.get('key2')).toBeUndefined(); + expect(timedMap.get('key3')).toBeUndefined(); + expect(timedMap.get('key4')).toEqual(4); + + jest.useRealTimers(); + }); + + it('should perform cleanup of entries exceeding the limit', () => { + timedMap.set('key1', 1); + timedMap.set('key2', 2); + timedMap.set('key3', 3); + timedMap.set('key4', 4); // This should trigger cleanup + + expect(timedMap.get('key1')).toBeUndefined(); + expect(timedMap.get('key2')).toEqual(2); + expect(timedMap.get('key3')).toEqual(3); + expect(timedMap.get('key4')).toEqual(4); + }); + + it('should return the correct size', () => { + timedMap.set('key1', 1); + timedMap.set('key2', 2); + timedMap.set('key3', 3); + + expect(timedMap.size).toEqual(3); + + timedMap.delete('key2'); + + expect(timedMap.size).toEqual(2); + }); + + it('should return the correct keys', () => { + timedMap.set('key1', 1); + timedMap.set('key2', 2); + timedMap.set('key3', 3); + + const keys = [...timedMap.keys()]; + + expect(keys).toEqual(['key1', 'key2', 'key3']); + }); + + it('should return the correct values', () => { + timedMap.set('key1', 1); + timedMap.set('key2', 2); + timedMap.set('key3', 3); + + const values = [...timedMap.values()]; + + expect(values).toEqual([1, 2, 3]); + }); + + it('should return the correct entries', () => { + timedMap.set('key1', 1); + timedMap.set('key2', 2); + timedMap.set('key3', 3); + + const entries = [...timedMap.entries()]; + + expect(entries).toEqual([ + ['key1', 1], + ['key2', 2], + ['key3', 3] + ]); + }); +}); \ No newline at end of file diff --git a/packages/util/src/index.ts b/packages/util/src/index.ts index 4b45ee5a..3c7441a8 100644 --- a/packages/util/src/index.ts +++ b/packages/util/src/index.ts @@ -28,6 +28,7 @@ export * from './singleton'; export * from './string'; export * from './task'; export * from './types'; +export * from './timedMap'; export * from './timer'; export * from './transactionalMap'; export * from './validate'; diff --git a/packages/util/src/timedMap.ts b/packages/util/src/timedMap.ts new file mode 100644 index 00000000..020c65d7 --- /dev/null +++ b/packages/util/src/timedMap.ts @@ -0,0 +1,173 @@ +export interface TimedMapOptions { + /** + * Time to live in milliseconds for entries in the map + */ + ttl?: number; + /** + * Maximum number of entries in the map + */ + limit?: number; +} + +/** + * Represents a map with timed entries. + * Entries in the map have an optional expiration time and can be automatically cleaned up. + * @template K The type of the keys in the map. + * @template T The type of the values in the map. + */ +export class TimedMap { + + private readonly map = new Map(); + private lastCleanup = 0; + + public constructor(private readonly options: TimedMapOptions) { + } + + /** + * Gets the number of key-value pairs in the TimedMap. + * @returns The number of key-value pairs in the TimedMap. + */ + public get size() : number { + return this.map.size; + } + + /** + * Retrieves the value associated with the specified key from the timed map. + * @param key - The key to retrieve the value for. + * @returns The value associated with the key, or undefined if the key does not exist. + */ + public get(key: K) : T | undefined { + const entry = this.map.get(key); + if (entry) { + entry.lastAccess = Date.now(); + return entry.value; + } + } + + /** + * Sets a key-value pair in the map. + * If the key already exists, updates the value and updates the last access timestamp. + * If the key does not exist, adds a new entry with the specified key, value, and creation timestamp. + * Performs cleanup if necessary. + * + * @param key - The key to set. + * @param value - The value to set. + * @returns The updated TimedMap instance. + */ + public set(key: K, value: T) : this { + const entry = this.map.get(key); + if (entry) { + entry.value = value; + entry.lastAccess = Date.now(); + } else { + this.map.set(key, { value, created: Date.now() }); + this.cleanup(); + } + return this; + } + + /** + * Deletes the entry with the specified key from the map. + * + * @param key - The key of the entry to delete. + * @returns `true` if the entry was successfully deleted, `false` otherwise. + */ + public delete(key: K) : boolean { + const entry = this.map.get(key); + if (entry) { + this.map.delete(key); + return true; + } + return false; + } + + /** + * Performs cleanup if necessary of expired entries and entries exceeding the limit. + */ + public cleanup() { + if (this.options.limit && this.size > this.options.limit) { + const sortedEntries = [...this.map.entries()].sort( + ([,a], [,b]) => (a.lastAccess ?? a.created ?? 0) - (b.lastAccess ?? b.created ?? 0) + ); + sortedEntries.slice(0, this.size - this.options.limit).forEach(([key]) => this.map.delete(key)); + } + + if (this.shouldCheckExpired() && this.options.ttl) { + const now = Date.now(); + this.lastCleanup = now + + const expiredEntries = new Array(); + for (const [key, entry] of this.map.entries()) { + if (now - (entry.lastAccess ?? entry.created) > this.options.ttl) { + expiredEntries.push(key); + } + } + + for (const key of expiredEntries) { + this.map.delete(key); + } + } + } + + /** + * Clears all entries from the map. + */ + public clear() : void { + this.map.clear(); + } + + /** + * Returns an iterable iterator of the keys in the TimedMap. + * @returns An iterable iterator of the keys. + */ + public *keys() : IterableIterator { + for (const [key] of this.entries()) { + yield key; + } + } + + /** + * Returns an iterable iterator of the values in the TimedMap. + * @returns An iterable iterator of the values. + */ + public *values() : IterableIterator { + for (const [,value] of this.entries()) { + yield value; + } + } + + /** + * Returns an iterable iterator that contains the entries of the timed map. + * Each entry is a key-value pair, represented as an array [key, value]. + * If the entries have expired based on the time-to-live (ttl) option, they are skipped. + * @returns An iterable iterator of key-value pairs. + */ + public *entries() : IterableIterator<[K, T]> { + const now = Date.now(); + const expiredEntries = new Array(); + const checkExpired = this.shouldCheckExpired(); + checkExpired && (this.lastCleanup = now); + + for (const [key, entry] of this.map.entries()) { + if (checkExpired && this.options.ttl && now - (entry.lastAccess ?? entry.created) > this.options.ttl) { + expiredEntries.push(key); + continue; + } + yield [key, entry.value]; + } + + if (expiredEntries) { + for (const key of expiredEntries) { + this.map.delete(key); + } + } + } + + /** + * Checks if the expiration time for the map entries has been reached. + * @returns {boolean} True if the expiration time has been reached, false otherwise. + */ + private shouldCheckExpired() { + return this.options.ttl && this.lastCleanup + this.options.ttl < Date.now(); + } +} \ No newline at end of file diff --git a/packages/vscode-extension/src/commands/apex/toggleTestCoverage.ts b/packages/vscode-extension/src/commands/apex/toggleTestCoverage.ts index bf0ca41b..8caa48df 100644 --- a/packages/vscode-extension/src/commands/apex/toggleTestCoverage.ts +++ b/packages/vscode-extension/src/commands/apex/toggleTestCoverage.ts @@ -4,11 +4,11 @@ import { vscodeCommand } from '../../lib/commandRouter'; import { CommandBase } from '../../lib/commandBase'; import { cache, substringBetweenLast } from '@vlocode/util'; -@vscodeCommand(VlocodeCommand.apexToggleCoverage) /** * Represents a command for toggling test coverage * highlighting in the editor for the an Apex class. */ +@vscodeCommand(VlocodeCommand.apexToggleCoverage) export default class ToggleApexTestCoverage extends CommandBase { private coverageShowingFor = new Set(); diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml index b81a4a7c..1d496346 100644 --- a/pnpm-lock.yaml +++ b/pnpm-lock.yaml @@ -64,32 +64,32 @@ importers: specifier: ^20 version: 20.4.2 '@typescript-eslint/eslint-plugin': - specifier: ^5.30.5 - version: 5.30.6(@typescript-eslint/parser@5.30.6)(eslint@8.19.0)(typescript@5.1.6) + specifier: ^5.62.0 + version: 5.62.0(@typescript-eslint/parser@5.62.0)(eslint@8.57.0)(typescript@5.1.6) '@typescript-eslint/parser': - specifier: ^5.30.5 - version: 5.30.6(eslint@8.19.0)(typescript@5.1.6) + specifier: ^5.62.0 + version: 5.62.0(eslint@8.57.0)(typescript@5.1.6) chalk: specifier: ^4.1.2 version: 4.1.2 eslint: - specifier: ^8.19.0 - version: 8.19.0 + specifier: ^8.57.0 + version: 8.57.0 eslint-config-prettier: - specifier: ^8.3.0 - version: 8.5.0(eslint@8.19.0) + specifier: ^8.10.0 + version: 8.10.0(eslint@8.57.0) eslint-plugin-import: - specifier: ^2.25.4 - version: 2.26.0(@typescript-eslint/parser@5.30.6)(eslint@8.19.0) + specifier: ^2.29.1 + version: 2.29.1(@typescript-eslint/parser@5.62.0)(eslint@8.57.0) eslint-plugin-jsdoc: - specifier: ^37.6.1 - version: 37.9.7(eslint@8.19.0) + specifier: ^37.9.7 + version: 37.9.7(eslint@8.57.0) eslint-plugin-prefer-arrow: specifier: ^1.2.3 - version: 1.2.3(eslint@8.19.0) + version: 1.2.3(eslint@8.57.0) eslint-plugin-prettier: - specifier: ^4.0.0 - version: 4.0.0(eslint-config-prettier@8.5.0)(eslint@8.19.0)(prettier@2.6.2) + specifier: ^4.2.1 + version: 4.2.1(eslint-config-prettier@8.10.0)(eslint@8.57.0)(prettier@2.6.2) fs-extra: specifier: '11' version: 11.2.0 @@ -119,7 +119,7 @@ importers: version: 2.6.2 ts-jest: specifier: ^29.1.1 - version: 29.1.1(@babel/core@7.23.6)(jest@29.7.0)(typescript@5.1.6) + version: 29.1.1(@babel/core@7.24.0)(jest@29.7.0)(typescript@5.1.6) typedoc: specifier: ^0.24.8 version: 0.24.8(typescript@5.1.6) @@ -130,6 +130,58 @@ importers: specifier: 5.1.6 version: 5.1.6(patch_hash=sjs4irdv5ckbkl3gggmzheybku) + packages/apex: + dependencies: + '@vlocode/core': + specifier: workspace:* + version: link:../core + '@vlocode/util': + specifier: workspace:* + version: link:../util + antlr4ng: + specifier: ^3.0.4 + version: 3.0.4(antlr4ng-cli@2.0.0) + devDependencies: + '@types/csv-parse': + specifier: ^1.2.2 + version: 1.2.2 + '@types/fs-extra': + specifier: ^11 + version: 11.0.4 + '@types/jest': + specifier: ^29.5.11 + version: 29.5.11 + '@types/jsforce': + specifier: 1.9.42 + version: 1.9.42(patch_hash=6yh4qlsazb5qjqmlnbys4ekmaq) + '@types/luxon': + specifier: ^3.3.0 + version: 3.3.0 + '@types/node': + specifier: ^20 + version: 20.4.2 + '@types/tough-cookie': + specifier: ^4.0.2 + version: 4.0.2 + antlr4ng-cli: + specifier: ^2.0.0 + version: 2.0.0 + jest: + specifier: ^29.7.0 + version: 29.7.0(@types/node@20.4.2)(ts-node@10.7.0) + nugget: + specifier: ^2.2.0 + version: 2.2.0 + shx: + specifier: ^0.3.4 + version: 0.3.4 + ts-jest: + specifier: ^29.1.1 + version: 29.1.1(@babel/core@7.23.6)(jest@29.7.0)(typescript@5.1.6) + typescript: + specifier: 5.1.6 + version: 5.1.6(patch_hash=sjs4irdv5ckbkl3gggmzheybku) + packages/cli: devDependencies: '@types/jest': @@ -138,6 +190,9 @@ importers: '@types/node': specifier: ^20 version: 20.4.2 + '@vlocode/apex': + specifier: workspace:* + version: link:../apex '@vlocode/core': specifier: workspace:* version: link:../core @@ -160,8 +215,8 @@ importers: specifier: ^4.1.2 version: 4.1.2 commander: - specifier: ^9.2.0 - version: 9.5.0 + specifier: ^11.1.0 + version: 11.1.0 esbuild-loader: specifier: ^4.0.3 version: 4.0.3(webpack@5.88.2) @@ -182,7 +237,7 @@ importers: version: 0.5.21 ts-jest: specifier: ^29.1.1 - version: 29.1.1(@babel/core@7.23.6)(jest@29.7.0)(typescript@5.1.6) + version: 29.1.1(@babel/core@7.24.0)(jest@29.7.0)(typescript@5.1.6) ts-loader: specifier: ^9.3.1 version: 9.4.0(typescript@5.1.6)(webpack@5.88.2) @@ -258,7 +313,7 @@ importers: version: 0.3.4 ts-jest: specifier: ^29.1.1 - version: 29.1.1(@babel/core@7.23.6)(jest@29.7.0)(typescript@5.1.6) + version: 29.1.1(@babel/core@7.24.0)(jest@29.7.0)(typescript@5.1.6) typescript: specifier: 5.1.6 version: 5.1.6(patch_hash=sjs4irdv5ckbkl3gggmzheybku) @@ -298,7 +353,7 @@ importers: version: 0.3.4 ts-jest: specifier: ^29.1.1 - version: 29.1.1(@babel/core@7.23.6)(jest@29.7.0)(typescript@5.1.6) + version: 29.1.1(@babel/core@7.24.0)(jest@29.7.0)(typescript@5.1.6) typescript: specifier: 5.1.6 version: 5.1.6(patch_hash=sjs4irdv5ckbkl3gggmzheybku) @@ -311,6 +366,9 @@ importers: '@vlocode/util': specifier: workspace:* version: link:../util + antlr4ng: + specifier: ^2.0.8 + version: 2.0.11(antlr4ng-cli@1.0.7) chalk: specifier: ^4.1.2 version: 4.1.2 @@ -365,7 +423,7 @@ importers: version: 0.3.4 ts-jest: specifier: ^29.1.1 - version: 29.1.1(@babel/core@7.23.6)(jest@29.7.0)(typescript@5.1.6) + version: 29.1.1(@babel/core@7.24.0)(jest@29.7.0)(typescript@5.1.6) typescript: specifier: 5.1.6 version: 5.1.6(patch_hash=sjs4irdv5ckbkl3gggmzheybku) @@ -414,7 +472,7 @@ importers: version: 0.3.4 ts-jest: specifier: ^29.1.1 - version: 29.1.1(@babel/core@7.23.6)(jest@29.7.0)(typescript@5.1.6) + version: 29.1.1(@babel/core@7.24.0)(jest@29.7.0)(typescript@5.1.6) typescript: specifier: 5.1.6 version: 5.1.6(patch_hash=sjs4irdv5ckbkl3gggmzheybku) @@ -451,7 +509,7 @@ importers: version: 0.3.4 ts-jest: specifier: ^29.1.1 - version: 29.1.1(@babel/core@7.23.6)(jest@29.7.0)(typescript@5.1.6) + version: 29.1.1(@babel/core@7.24.0)(jest@29.7.0)(typescript@5.1.6) typescript: specifier: 5.1.6 version: 5.1.6(patch_hash=sjs4irdv5ckbkl3gggmzheybku) @@ -506,7 +564,7 @@ importers: version: 0.3.4 ts-jest: specifier: ^29.1.1 - version: 29.1.1(@babel/core@7.23.6)(jest@29.7.0)(typescript@5.1.6) + version: 29.1.1(@babel/core@7.24.0)(jest@29.7.0)(typescript@5.1.6) typescript: specifier: 5.1.6 version: 5.1.6(patch_hash=sjs4irdv5ckbkl3gggmzheybku) @@ -617,7 +675,7 @@ importers: version: 0.5.21 ts-jest: specifier: ^29.1.1 - version: 29.1.1(@babel/core@7.23.6)(jest@29.7.0)(typescript@5.1.6) + version: 29.1.1(@babel/core@7.24.0)(jest@29.7.0)(typescript@5.1.6) ts-loader: specifier: ^9.4.0 version: 9.4.0(typescript@5.1.6)(webpack@5.88.2) @@ -657,6 +715,11 @@ importers: packages: + /@aashutoshrathi/word-wrap@1.2.6: + resolution: {integrity: sha512-1Yjs2SvM8TflER/OD3cOjhWWOZb58A2t7wpE2S9XfBYTiIl+XFhQG2bjy4Pu1I+EAlCNUzRDYDdFwFYUKvXcIA==} + engines: {node: '>=0.10.0'} + dev: true + /@ampproject/remapping@2.2.1: resolution: {integrity: sha512-lFMjJTrFL3j7L9yBxwYfCq2k6qqwHyzuUl/XBnif78PWTJYyL/dfowQHWE3sp6U6ZzqWiiIZnpTMO96zhkjwtg==} engines: {node: '>=6.0.0'} @@ -665,6 +728,14 @@ packages: '@jridgewell/trace-mapping': 0.3.20 dev: true + /@ampproject/remapping@2.3.0: + resolution: {integrity: sha512-30iZtAPgz+LTIYoeivqYo853f02jBYSd5uGnGpkFV0M3xOt9aN73erkgYAmZU43x4VfqcnLxW9Kpg3R5LC4YYw==} + engines: {node: '>=6.0.0'} + dependencies: + '@jridgewell/gen-mapping': 0.3.5 + '@jridgewell/trace-mapping': 0.3.25 + dev: true + /@babel/code-frame@7.23.5: resolution: {integrity: sha512-CgH3s1a96LipHCmSUmYFPwY7MNx8C3avkq7i4Wl3cfa662ldtUe4VM1TPXX70pfmrlWTb6jLqTYrZyT2ZTJBgA==} engines: {node: '>=6.9.0'} @@ -701,6 +772,29 @@ packages: - supports-color dev: true + /@babel/core@7.24.0: + resolution: {integrity: sha512-fQfkg0Gjkza3nf0c7/w6Xf34BW4YvzNfACRLmmb7XRLa6XHdR+K9AlJlxneFfWYf6uhOzuzZVTjF/8KfndZANw==} + engines: {node: '>=6.9.0'} + dependencies: + '@ampproject/remapping': 2.3.0 + '@babel/code-frame': 7.23.5 + '@babel/generator': 7.23.6 + '@babel/helper-compilation-targets': 7.23.6 + '@babel/helper-module-transforms': 7.23.3(@babel/core@7.24.0) + '@babel/helpers': 7.24.0 + '@babel/parser': 7.24.0 + '@babel/template': 7.24.0 + '@babel/traverse': 7.24.0 + '@babel/types': 7.24.0 + convert-source-map: 2.0.0 + debug: 4.3.4(supports-color@8.1.1) + gensync: 1.0.0-beta.2 + json5: 2.2.3 + semver: 6.3.1 + transitivePeerDependencies: + - supports-color + dev: true + /@babel/generator@7.23.6: resolution: {integrity: sha512-qrSfCYxYQB5owCmGLbl8XRpX1ytXlpueOb0N0UmQwA073KZxejgQTzAmJezxvpwQD9uGtK2shHdi55QT+MbjIw==} engines: {node: '>=6.9.0'} @@ -763,6 +857,20 @@ packages: '@babel/helper-validator-identifier': 7.22.20 dev: true + /@babel/helper-module-transforms@7.23.3(@babel/core@7.24.0): + resolution: {integrity: sha512-7bBs4ED9OmswdfDzpz4MpWgSrV7FXlc3zIagvLFjS5H+Mk7Snr21vQ6QwrsoCGMfNC4e4LQPdoULEt4ykz0SRQ==} + engines: {node: '>=6.9.0'} + peerDependencies: + '@babel/core': ^7.0.0 + dependencies: + '@babel/core': 7.24.0 + '@babel/helper-environment-visitor': 7.22.20 + '@babel/helper-module-imports': 7.22.15 + '@babel/helper-simple-access': 7.22.5 + '@babel/helper-split-export-declaration': 7.22.6 + '@babel/helper-validator-identifier': 7.22.20 + dev: true + /@babel/helper-plugin-utils@7.22.5: resolution: {integrity: sha512-uLls06UVKgFG9QD4OeFYLEGteMIAa5kpTPcFL28yuCIIzsf6ZyKZMllKVOCZFhiZ5ptnwX4mtKdWCBE/uT4amg==} engines: {node: '>=6.9.0'} @@ -808,6 +916,17 @@ packages: - supports-color dev: true + /@babel/helpers@7.24.0: + resolution: {integrity: sha512-ulDZdc0Aj5uLc5nETsa7EPx2L7rM0YJM8r7ck7U73AXi7qOV44IHHRAYZHY6iU1rr3C5N4NtTmMRUJP6kwCWeA==} + engines: {node: '>=6.9.0'} + dependencies: + '@babel/template': 7.24.0 + '@babel/traverse': 7.24.0 + '@babel/types': 7.24.0 + transitivePeerDependencies: + - supports-color + dev: true + /@babel/highlight@7.23.4: resolution: {integrity: sha512-acGdbYSfp2WheJoJm/EBBBLh/ID8KDc64ISZ9DYtBmC8/Q204PZJLHyzeB5qMzJ5trcOkybd78M4x2KWsUq++A==} engines: {node: '>=6.9.0'} @@ -825,6 +944,14 @@ packages: '@babel/types': 7.23.6 dev: true + /@babel/parser@7.24.0: + resolution: {integrity: sha512-QuP/FxEAzMSjXygs8v4N9dvdXzEHN4W1oF3PxuWAtPo08UdM17u89RDMgjLn/mlc56iM0HlLmVkO/wgR+rDgHg==} + engines: {node: '>=6.0.0'} + hasBin: true + dependencies: + '@babel/types': 7.24.0 + dev: true + /@babel/plugin-syntax-async-generators@7.8.4(@babel/core@7.23.6): resolution: {integrity: sha512-tycmZxkGfZaxhMRbXlPXuVFpdWlXpir2W4AMhSJgRKzk/eDlIXOhb2LHWoLpDF7TEHylV5zNhykX6KAgHJmTNw==} peerDependencies: @@ -976,6 +1103,15 @@ packages: '@babel/types': 7.23.6 dev: true + /@babel/template@7.24.0: + resolution: {integrity: sha512-Bkf2q8lMB0AFpX0NFEqSbx1OkTHf0f+0j82mkw+ZpzBnkk7e9Ql0891vlfgi+kHwOk8tQjiQHpqh4LaSa0fKEA==} + engines: {node: '>=6.9.0'} + dependencies: + '@babel/code-frame': 7.23.5 + '@babel/parser': 7.24.0 + '@babel/types': 7.24.0 + dev: true + /@babel/traverse@7.23.6: resolution: {integrity: sha512-czastdK1e8YByZqezMPFiZ8ahwVMh/ESl9vPgvgdB9AmFMGP5jfpFax74AQgl5zj4XHzqeYAg2l8PuUeRS1MgQ==} engines: {node: '>=6.9.0'} @@ -994,6 +1130,24 @@ packages: - supports-color dev: true + /@babel/traverse@7.24.0: + resolution: {integrity: sha512-HfuJlI8qq3dEDmNU5ChzzpZRWq+oxCZQyMzIMEqLho+AQnhMnKQUzH6ydo3RBl/YjPCuk68Y6s0Gx0AeyULiWw==} + engines: {node: '>=6.9.0'} + dependencies: + '@babel/code-frame': 7.23.5 + '@babel/generator': 7.23.6 + '@babel/helper-environment-visitor': 7.22.20 + '@babel/helper-function-name': 7.23.0 + '@babel/helper-hoist-variables': 7.22.5 + '@babel/helper-split-export-declaration': 7.22.6 + '@babel/parser': 7.24.0 + '@babel/types': 7.24.0 + debug: 4.3.4(supports-color@8.1.1) + globals: 11.12.0 + transitivePeerDependencies: + - supports-color + dev: true + /@babel/types@7.23.6: resolution: {integrity: sha512-+uarb83brBzPKN38NX1MkB6vb6+mwvR6amUulqAE7ccQw1pEl+bCia9TbdG1lsnFP7lZySvUn37CHyXQdfTwzg==} engines: {node: '>=6.9.0'} @@ -1003,6 +1157,15 @@ packages: to-fast-properties: 2.0.0 dev: true + /@babel/types@7.24.0: + resolution: {integrity: sha512-+j7a5c253RfKh8iABBhywc8NSfP5LURe7Uh4qpsh6jc+aLJguvmIUBdjSdEMQv2bENrCR5MfRdjGo7vzS/ob7w==} + engines: {node: '>=6.9.0'} + dependencies: + '@babel/helper-string-parser': 7.23.4 + '@babel/helper-validator-identifier': 7.22.20 + to-fast-properties: 2.0.0 + dev: true + /@bcoe/v8-coverage@0.2.3: resolution: {integrity: sha512-0hYQ8SB4Db5zvZB4axdMHGwEaQjkZzFjQiN9LVYvIFB2nSUHW9tYpxWriPrWDASIxiaXax83REcLxuSdnGPZtw==} dev: true @@ -1240,14 +1403,29 @@ packages: dev: true optional: true - /@eslint/eslintrc@1.3.0: - resolution: {integrity: sha512-UWW0TMTmk2d7hLcWD1/e2g5HDM/HQ3csaLSqXCfqwh4uNDuNqlaKWXmEsL4Cs41Z0KnILNvwbHAah3C2yt06kw==} + /@eslint-community/eslint-utils@4.4.0(eslint@8.57.0): + resolution: {integrity: sha512-1/sA4dwrzBAyeUoQ6oxahHKmrZvsnLCg4RfxW3ZFGGmQkSNQPFNLV9CUEFQP1x9EYXHTo5p6xdhZM1Ne9p/AfA==} + engines: {node: ^12.22.0 || ^14.17.0 || >=16.0.0} + peerDependencies: + eslint: ^6.0.0 || ^7.0.0 || >=8.0.0 + dependencies: + eslint: 8.57.0 + eslint-visitor-keys: 3.4.3 + dev: true + + /@eslint-community/regexpp@4.10.0: + resolution: {integrity: sha512-Cu96Sd2By9mCNTx2iyKOmq10v22jUVQv0lQnlGNy16oE9589yE+QADPbrMGCkA51cKZSg3Pu/aTJVTGfL/qjUA==} + engines: {node: ^12.0.0 || ^14.0.0 || >=16.0.0} + dev: true + + /@eslint/eslintrc@2.1.4: + resolution: {integrity: sha512-269Z39MS6wVJtsoUl10L60WdkhJVdPG24Q4eZTH3nnF6lpvSShEK3wQjDX9JRWAUPvPh7COouPpU9IrqaZFvtQ==} engines: {node: ^12.22.0 || ^14.17.0 || >=16.0.0} dependencies: ajv: 6.12.6 debug: 4.3.4(supports-color@8.1.1) - espree: 9.3.2 - globals: 13.16.0 + espree: 9.6.1 + globals: 13.24.0 ignore: 5.2.0 import-fresh: 3.3.0 js-yaml: 4.1.0 @@ -1257,6 +1435,11 @@ packages: - supports-color dev: true + /@eslint/js@8.57.0: + resolution: {integrity: sha512-Ys+3g2TaW7gADOJzPt83SJtCDhMjndcDMFVQ/Tj9iA1BfJzFKD9mAUXT3OenpuPHbI6P/myECxRJrofUsDx/5g==} + engines: {node: ^12.22.0 || ^14.17.0 || >=16.0.0} + dev: true + /@gar/promisify@1.1.3: resolution: {integrity: sha512-k2Ty1JcVojjJFwrg/ThKi2ujJ7XNLYaFGNB/bWT9wGR+oSMJHMa5w+CUq6p/pVrKeNNgA7pCqEcjSnHVoqJQFw==} dev: true @@ -1272,19 +1455,24 @@ packages: tslib: 1.14.1 dev: true - /@humanwhocodes/config-array@0.9.5: - resolution: {integrity: sha512-ObyMyWxZiCu/yTisA7uzx81s40xR2fD5Cg/2Kq7G02ajkNubJf6BopgDTmDyc3U7sXpNKM8cYOw7s7Tyr+DnCw==} + /@humanwhocodes/config-array@0.11.14: + resolution: {integrity: sha512-3T8LkOmg45BV5FICb15QQMsyUSWrQ8AygVfC7ZG32zOalnqrilm018ZVCw0eapXux8FtA33q8PSRSstjee3jSg==} engines: {node: '>=10.10.0'} dependencies: - '@humanwhocodes/object-schema': 1.2.1 + '@humanwhocodes/object-schema': 2.0.2 debug: 4.3.4(supports-color@8.1.1) minimatch: 3.1.2 transitivePeerDependencies: - supports-color dev: true - /@humanwhocodes/object-schema@1.2.1: - resolution: {integrity: sha512-ZnQMnLV4e7hDlUvw8H+U8ASL02SS2Gn6+9Ac3wGGLIe7+je2AeAOxPY+izIPJDfFDb7eDjev0Us8MO1iFRN8hA==} + /@humanwhocodes/module-importer@1.0.1: + resolution: {integrity: sha512-bxveV4V8v5Yb4ncFTT3rPSgZBOpCkjfK0y4oVVVJwIuDVBRMDXrPyXRL988i5ap9m9bnyEEjWfm5WkBmtffLfA==} + engines: {node: '>=12.22'} + dev: true + + /@humanwhocodes/object-schema@2.0.2: + resolution: {integrity: sha512-6EwiSjwWYP7pTckG6I5eyFANjPhmPjUX9JRLUSfNPC7FX7zK9gyZAfUEaECL6ALTpGX5AjnBq3C9XmVWPitNpw==} dev: true /@hutson/parse-repository-url@3.0.2: @@ -1531,16 +1719,35 @@ packages: '@jridgewell/trace-mapping': 0.3.20 dev: true + /@jridgewell/gen-mapping@0.3.5: + resolution: {integrity: sha512-IzL8ZoEDIBRWEzlCcRhOaCupYyN5gdIK+Q6fbFdPDg6HqX6jpkItn7DFIpW9LQzXG6Df9sA7+OKnq0qlz/GaQg==} + engines: {node: '>=6.0.0'} + dependencies: + '@jridgewell/set-array': 1.2.1 + '@jridgewell/sourcemap-codec': 1.4.15 + '@jridgewell/trace-mapping': 0.3.25 + dev: true + /@jridgewell/resolve-uri@3.1.1: resolution: {integrity: sha512-dSYZh7HhCDtCKm4QakX0xFpsRDqjjtZf/kjI/v3T3Nwt5r8/qz/M19F9ySyOqU94SXBmeG9ttTul+YnR4LOxFA==} engines: {node: '>=6.0.0'} dev: true + /@jridgewell/resolve-uri@3.1.2: + resolution: {integrity: sha512-bRISgCIjP20/tbWSPWMEi54QVPRZExkuD9lJL+UIxUKtwVJA8wW1Trb1jMs1RFXo1CBTNZ/5hpC9QvmKWdopKw==} + engines: {node: '>=6.0.0'} + dev: true + /@jridgewell/set-array@1.1.2: resolution: {integrity: sha512-xnkseuNADM0gt2bs+BvhO0p78Mk762YnZdsuzFV018NoG1Sj1SCQvpSqa7XUaTam5vAGasABV9qXASMKnFMwMw==} engines: {node: '>=6.0.0'} dev: true + /@jridgewell/set-array@1.2.1: + resolution: {integrity: sha512-R8gLRTZeyp03ymzP/6Lil/28tGeGEzhx1q2k703KGWRAI1VdvPIXdG70VJc2pAMw3NA6JKL5hhFu1sJX0Mnn/A==} + engines: {node: '>=6.0.0'} + dev: true + /@jridgewell/source-map@0.3.5: resolution: {integrity: sha512-UTYAUj/wviwdsMfzoSJspJxbkH5o1snzwX0//0ENX1u/55kkZZkcTZP6u9bwKGkv+dkk9at4m1Cpt0uY80kcpQ==} dependencies: @@ -1559,6 +1766,13 @@ packages: '@jridgewell/sourcemap-codec': 1.4.15 dev: true + /@jridgewell/trace-mapping@0.3.25: + resolution: {integrity: sha512-vNk6aEwybGtawWmy/PzwnGDOjCkLWSD2wqvjGGAgOAwCGWySYXfYoxt00IJkTF+8Lb57DwOb3Aa0o9CApepiYQ==} + dependencies: + '@jridgewell/resolve-uri': 3.1.2 + '@jridgewell/sourcemap-codec': 1.4.15 + dev: true + /@lerna-lite/cli@1.6.0: resolution: {integrity: sha512-56xEap4n1PPGXN5KjGZz7ljdgLiHzPR50b4MwG2xl3RcQBMBgWTRLYd84JZYMDmaeGg39cpoZKbywpmbIhF6Wg==} engines: {node: '>=14.15.0', npm: '>=8.0.0'} @@ -1766,7 +1980,7 @@ packages: engines: {node: '>= 8'} dependencies: '@nodelib/fs.scandir': 2.1.5 - fastq: 1.13.0 + fastq: 1.17.1 /@npmcli/fs@2.1.0: resolution: {integrity: sha512-DmfBvNXGaetMxj9LTp8NAN9vEidXURrf5ZTslQzEAi/6GbW+4yjaLFQc6Tue5cpZ9Frlk4OBo/Snf1Bh/S7qTQ==} @@ -1848,7 +2062,7 @@ packages: '@oclif/help': 1.0.1(supports-color@8.1.1) '@oclif/parser': 3.8.7 debug: 4.3.4(supports-color@8.1.1) - semver: 7.5.4 + semver: 7.6.0 transitivePeerDependencies: - supports-color dev: true @@ -2133,7 +2347,7 @@ packages: jsforce: 1.11.0(patch_hash=e7ayos5jozkcmldmo4pozdageu) jsonwebtoken: 8.5.0 mkdirp: 1.0.4 - semver: 7.5.4 + semver: 7.6.0 ts-retry-promise: 0.6.1 transitivePeerDependencies: - supports-color @@ -2414,6 +2628,10 @@ packages: resolution: {integrity: sha512-wOuvG1SN4Us4rez+tylwwwCV1psiNVOkJeM3AUWUNWg/jDQY2+HE/444y5gc+jBmRqASOm2Oeh5c1axHobwRKQ==} dev: true + /@types/json-schema@7.0.15: + resolution: {integrity: sha512-5+fP8P8MFNC+AyZCDxrB2pkZFPGzqQWUzpSeuuVLvm8VMcorNYavBqoFcxK8bQz4Qsbn4oUEEem4wDLfcysGHA==} + dev: true + /@types/json5@0.0.29: resolution: {integrity: sha512-dRLjCWHYg4oaA77cxO64oO+7JwCwnIzkZPdrrC71jQmQtlhM556pwKo5bUzqvZndkVbeFLIIi+9TC40JNF5hNQ==} dev: true @@ -2468,6 +2686,10 @@ packages: /@types/semver@7.3.13: resolution: {integrity: sha512-21cFJr9z3g5dW8B0CVI9g2O9beqaThGQ6ZFBqHfwhzLDKUxaqTIy3vnfah/UPkfOiF2pLq+tGz+W8RyCskuslw==} + /@types/semver@7.5.8: + resolution: {integrity: sha512-I8EUhyrgfLrcTkzV3TSsGyl1tSuPrEDzr0yd5m90UgNxQkyDXULk3b6MlQqTCpZpNtWe1K0hzclnZkTcLBe2UQ==} + dev: true + /@types/sinon@10.0.11: resolution: {integrity: sha512-dmZsHlBsKUtBpHriNjlK0ndlvEh8dcb9uV9Afsbt89QIyydpC7NcR+nWlAhASfy3GHnxTl4FX/aKE7XZUt/B4g==} dependencies: @@ -2536,8 +2758,8 @@ packages: dev: true optional: true - /@typescript-eslint/eslint-plugin@5.30.6(@typescript-eslint/parser@5.30.6)(eslint@8.19.0)(typescript@5.1.6): - resolution: {integrity: sha512-J4zYMIhgrx4MgnZrSDD7sEnQp7FmhKNOaqaOpaoQ/SfdMfRB/0yvK74hTnvH+VQxndZynqs5/Hn4t+2/j9bADg==} + /@typescript-eslint/eslint-plugin@5.62.0(@typescript-eslint/parser@5.62.0)(eslint@8.57.0)(typescript@5.1.6): + resolution: {integrity: sha512-TiZzBSJja/LbhNPvk6yc0JrX9XqhQ0hdh6M2svYfsHGejaKFIAGd9MQ+ERIMzLGlN/kZoYIgdxFV0PuljTKXag==} engines: {node: ^12.22.0 || ^14.17.0 || >=16.0.0} peerDependencies: '@typescript-eslint/parser': ^5.0.0 @@ -2547,15 +2769,16 @@ packages: typescript: optional: true dependencies: - '@typescript-eslint/parser': 5.30.6(eslint@8.19.0)(typescript@5.1.6) - '@typescript-eslint/scope-manager': 5.30.6 - '@typescript-eslint/type-utils': 5.30.6(eslint@8.19.0)(typescript@5.1.6) - '@typescript-eslint/utils': 5.30.6(eslint@8.19.0)(typescript@5.1.6) + '@eslint-community/regexpp': 4.10.0 + '@typescript-eslint/parser': 5.62.0(eslint@8.57.0)(typescript@5.1.6) + '@typescript-eslint/scope-manager': 5.62.0 + '@typescript-eslint/type-utils': 5.62.0(eslint@8.57.0)(typescript@5.1.6) + '@typescript-eslint/utils': 5.62.0(eslint@8.57.0)(typescript@5.1.6) debug: 4.3.4(supports-color@8.1.1) - eslint: 8.19.0 - functional-red-black-tree: 1.0.1 + eslint: 8.57.0 + graphemer: 1.4.0 ignore: 5.2.0 - regexpp: 3.2.0 + natural-compare-lite: 1.4.0 semver: 7.5.4 tsutils: 3.21.0(typescript@5.1.6) typescript: 5.1.6(patch_hash=sjs4irdv5ckbkl3gggmzheybku) @@ -2563,8 +2786,8 @@ packages: - supports-color dev: true - /@typescript-eslint/parser@5.30.6(eslint@8.19.0)(typescript@5.1.6): - resolution: {integrity: sha512-gfF9lZjT0p2ZSdxO70Xbw8w9sPPJGfAdjK7WikEjB3fcUI/yr9maUVEdqigBjKincUYNKOmf7QBMiTf719kbrA==} + /@typescript-eslint/parser@5.62.0(eslint@8.57.0)(typescript@5.1.6): + resolution: {integrity: sha512-VlJEV0fOQ7BExOsHYAGrgbEiZoi8D+Bl2+f6V2RrXerRSylnp+ZBHmPvaIa8cz0Ajx7WO7Z5RqfgYg7ED1nRhA==} engines: {node: ^12.22.0 || ^14.17.0 || >=16.0.0} peerDependencies: eslint: ^6.0.0 || ^7.0.0 || ^8.0.0 @@ -2573,26 +2796,26 @@ packages: typescript: optional: true dependencies: - '@typescript-eslint/scope-manager': 5.30.6 - '@typescript-eslint/types': 5.30.6 - '@typescript-eslint/typescript-estree': 5.30.6(typescript@5.1.6) + '@typescript-eslint/scope-manager': 5.62.0 + '@typescript-eslint/types': 5.62.0 + '@typescript-eslint/typescript-estree': 5.62.0(typescript@5.1.6) debug: 4.3.4(supports-color@8.1.1) - eslint: 8.19.0 + eslint: 8.57.0 typescript: 5.1.6(patch_hash=sjs4irdv5ckbkl3gggmzheybku) transitivePeerDependencies: - supports-color dev: true - /@typescript-eslint/scope-manager@5.30.6: - resolution: {integrity: sha512-Hkq5PhLgtVoW1obkqYH0i4iELctEKixkhWLPTYs55doGUKCASvkjOXOd/pisVeLdO24ZX9D6yymJ/twqpJiG3g==} + /@typescript-eslint/scope-manager@5.62.0: + resolution: {integrity: sha512-VXuvVvZeQCQb5Zgf4HAxc04q5j+WrNAtNh9OwCsCgpKqESMTu3tF/jhZ3xG6T4NZwWl65Bg8KuS2uEvhSfLl0w==} engines: {node: ^12.22.0 || ^14.17.0 || >=16.0.0} dependencies: - '@typescript-eslint/types': 5.30.6 - '@typescript-eslint/visitor-keys': 5.30.6 + '@typescript-eslint/types': 5.62.0 + '@typescript-eslint/visitor-keys': 5.62.0 dev: true - /@typescript-eslint/type-utils@5.30.6(eslint@8.19.0)(typescript@5.1.6): - resolution: {integrity: sha512-GFVVzs2j0QPpM+NTDMXtNmJKlF842lkZKDSanIxf+ArJsGeZUIaeT4jGg+gAgHt7AcQSFwW7htzF/rbAh2jaVA==} + /@typescript-eslint/type-utils@5.62.0(eslint@8.57.0)(typescript@5.1.6): + resolution: {integrity: sha512-xsSQreu+VnfbqQpW5vnCJdq1Z3Q0U31qiWmRhr98ONQmcp/yhiPJFPq8MXiJVLiksmOKSjIldZzkebzHuCGzew==} engines: {node: ^12.22.0 || ^14.17.0 || >=16.0.0} peerDependencies: eslint: '*' @@ -2601,22 +2824,23 @@ packages: typescript: optional: true dependencies: - '@typescript-eslint/utils': 5.30.6(eslint@8.19.0)(typescript@5.1.6) + '@typescript-eslint/typescript-estree': 5.62.0(typescript@5.1.6) + '@typescript-eslint/utils': 5.62.0(eslint@8.57.0)(typescript@5.1.6) debug: 4.3.4(supports-color@8.1.1) - eslint: 8.19.0 + eslint: 8.57.0 tsutils: 3.21.0(typescript@5.1.6) typescript: 5.1.6(patch_hash=sjs4irdv5ckbkl3gggmzheybku) transitivePeerDependencies: - supports-color dev: true - /@typescript-eslint/types@5.30.6: - resolution: {integrity: sha512-HdnP8HioL1F7CwVmT4RaaMX57RrfqsOMclZc08wGMiDYJBsLGBM7JwXM4cZJmbWLzIR/pXg1kkrBBVpxTOwfUg==} + /@typescript-eslint/types@5.62.0: + resolution: {integrity: sha512-87NVngcbVXUahrRTqIK27gD2t5Cu1yuCXxbLcFtCzZGlfyVWWh8mLHkoxzjsB6DDNnvdL+fW8MiwPEJyGJQDgQ==} engines: {node: ^12.22.0 || ^14.17.0 || >=16.0.0} dev: true - /@typescript-eslint/typescript-estree@5.30.6(typescript@5.1.6): - resolution: {integrity: sha512-Z7TgPoeYUm06smfEfYF0RBkpF8csMyVnqQbLYiGgmUSTaSXTP57bt8f0UFXstbGxKIreTwQCujtaH0LY9w9B+A==} + /@typescript-eslint/typescript-estree@5.62.0(typescript@5.1.6): + resolution: {integrity: sha512-CmcQ6uY7b9y694lKdRB8FEel7JbU/40iSAPomu++SjLMntB+2Leay2LO6i8VnJk58MtE9/nQSFIH6jpyRWyYzA==} engines: {node: ^12.22.0 || ^14.17.0 || >=16.0.0} peerDependencies: typescript: '*' @@ -2624,42 +2848,48 @@ packages: typescript: optional: true dependencies: - '@typescript-eslint/types': 5.30.6 - '@typescript-eslint/visitor-keys': 5.30.6 + '@typescript-eslint/types': 5.62.0 + '@typescript-eslint/visitor-keys': 5.62.0 debug: 4.3.4(supports-color@8.1.1) globby: 11.1.0 is-glob: 4.0.3 - semver: 7.5.4 + semver: 7.6.0 tsutils: 3.21.0(typescript@5.1.6) typescript: 5.1.6(patch_hash=sjs4irdv5ckbkl3gggmzheybku) transitivePeerDependencies: - supports-color dev: true - /@typescript-eslint/utils@5.30.6(eslint@8.19.0)(typescript@5.1.6): - resolution: {integrity: sha512-xFBLc/esUbLOJLk9jKv0E9gD/OH966M40aY9jJ8GiqpSkP2xOV908cokJqqhVd85WoIvHVHYXxSFE4cCSDzVvA==} + /@typescript-eslint/utils@5.62.0(eslint@8.57.0)(typescript@5.1.6): + resolution: {integrity: sha512-n8oxjeb5aIbPFEtmQxQYOLI0i9n5ySBEY/ZEHHZqKQSFnxio1rv6dthascc9dLuwrL0RC5mPCxB7vnAVGAYWAQ==} engines: {node: ^12.22.0 || ^14.17.0 || >=16.0.0} peerDependencies: eslint: ^6.0.0 || ^7.0.0 || ^8.0.0 dependencies: - '@types/json-schema': 7.0.11 - '@typescript-eslint/scope-manager': 5.30.6 - '@typescript-eslint/types': 5.30.6 - '@typescript-eslint/typescript-estree': 5.30.6(typescript@5.1.6) - eslint: 8.19.0 + '@eslint-community/eslint-utils': 4.4.0(eslint@8.57.0) + '@types/json-schema': 7.0.15 + '@types/semver': 7.5.8 + '@typescript-eslint/scope-manager': 5.62.0 + '@typescript-eslint/types': 5.62.0 + '@typescript-eslint/typescript-estree': 5.62.0(typescript@5.1.6) + eslint: 8.57.0 eslint-scope: 5.1.1 - eslint-utils: 3.0.0(eslint@8.19.0) + semver: 7.5.4 transitivePeerDependencies: - supports-color - typescript dev: true - /@typescript-eslint/visitor-keys@5.30.6: - resolution: {integrity: sha512-41OiCjdL2mCaSDi2SvYbzFLlqqlm5v1ZW9Ym55wXKL/Rx6OOB1IbuFGo71Fj6Xy90gJDFTlgOS+vbmtGHPTQQA==} + /@typescript-eslint/visitor-keys@5.62.0: + resolution: {integrity: sha512-07ny+LHRzQXepkGg6w0mFY41fVUNBrL2Roj/++7V1txKugfjm/Ci/qSND03r2RhlJhJYMcTn9AhhSSqQp0Ysyw==} engines: {node: ^12.22.0 || ^14.17.0 || >=16.0.0} dependencies: - '@typescript-eslint/types': 5.30.6 - eslint-visitor-keys: 3.3.0 + '@typescript-eslint/types': 5.62.0 + eslint-visitor-keys: 3.4.3 + dev: true + + /@ungap/structured-clone@1.2.0: + resolution: {integrity: sha512-zuVdFrMJiuCDQUMCzQaD6KL28MjnqqN8XnAqiEq9PNm/hCPTSGfrXCOfwj1ow4LFb/tNymJPwsNbVePc1xFqrQ==} dev: true /@vscode/test-electron@2.3.8: @@ -2897,12 +3127,12 @@ packages: acorn: 8.10.0 dev: true - /acorn-jsx@5.3.2(acorn@8.10.0): + /acorn-jsx@5.3.2(acorn@8.11.3): resolution: {integrity: sha512-rq9s+JNhf0IChjtDXxllJ7g41oZk5SlXtp0LHwyA5cejwn7vKmKp4pPri6YEePv2PU65sAsegbXtIinmDFDXgQ==} peerDependencies: acorn: ^6.0.0 || ^7.0.0 || ^8.0.0 dependencies: - acorn: 8.10.0 + acorn: 8.11.3 dev: true /acorn-walk@7.2.0: @@ -2932,6 +3162,12 @@ packages: engines: {node: '>=0.4.0'} hasBin: true + /acorn@8.11.3: + resolution: {integrity: sha512-Y9rRfJG5jcKOE0CLisYbojUjIrIEE7AGMzA/Sm4BslANhbS+cDMpgBdcPT91oJ7OuJ9hYJBx59RjbhxVnrF8Xg==} + engines: {node: '>=0.4.0'} + hasBin: true + dev: true + /add-stream@1.0.0: resolution: {integrity: sha512-qQLMr+8o0WC4FZGQTcJiKBVC59JylcPSrTtk6usvmIDFUOCKegapy1VHQwRbFMOFyb/inzUVqHs+eMYKDM1YeQ==} dev: true @@ -3077,6 +3313,31 @@ packages: resolution: {integrity: sha512-QXu7BPrP29VllRxH8GwB7x5iX5qWKAAMLqKQGWTeLWVlNHNOpVMJ91dsxQAIWXpjuW5wqvxu3Jd/nRjrJ+0pqg==} dev: true + /antlr4ng-cli@1.0.7: + resolution: {integrity: sha512-qN2FsDBmLvsQcA5CWTrPz8I8gNXeS1fgXBBhI78VyxBSBV/EJgqy8ks6IDTC9jyugpl40csCQ4sL5K4i2YZ/2w==} + hasBin: true + dev: false + + /antlr4ng-cli@2.0.0: + resolution: {integrity: sha512-oAt5OSSYhRQn1PgahtpAP4Vp3BApCoCqlzX7Q8ZUWWls4hX59ryYuu0t7Hwrnfk796OxP/vgIJaqxdltd/oEvQ==} + hasBin: true + + /antlr4ng@2.0.11(antlr4ng-cli@1.0.7): + resolution: {integrity: sha512-9jM91VVtHSqHkAHQsXHaoaiewFETMvUTI1/tXvwTiFw4f7zke3IGlwEyoKN9NS0FqIwDKFvUNW2e1cKPniTkVQ==} + peerDependencies: + antlr4ng-cli: 1.0.7 + dependencies: + antlr4ng-cli: 1.0.7 + dev: false + + /antlr4ng@3.0.4(antlr4ng-cli@2.0.0): + resolution: {integrity: sha512-u1Ww6wVv9hq70E9AaYe5qW3ba8hvnjJdO3ZsKnb3iJWFV/medLEEhbyWwXCvvD2ef0ptdaiIUgmaazS/WE6uyQ==} + peerDependencies: + antlr4ng-cli: ^2.0.0 + dependencies: + antlr4ng-cli: 2.0.0 + dev: false + /anymatch@1.3.2: resolution: {integrity: sha512-0XNayC8lTHQ2OI8aljNCN3sSx6hsr/1+rlcDAotXJR7C1oZZHCNsfpbKwMjRA3Uqb5tF1Rae2oloTr4xpq+WjA==} dependencies: @@ -3196,18 +3457,26 @@ packages: engines: {node: '>=0.10.0'} dev: true + /array-buffer-byte-length@1.0.1: + resolution: {integrity: sha512-ahC5W1xgou+KTXix4sAO8Ki12Q+jf4i0+tmk3sC+zgcynshkHxzpXdImBehiUYKKKDwvfFiJl1tZt6ewscS1Mg==} + engines: {node: '>= 0.4'} + dependencies: + call-bind: 1.0.7 + is-array-buffer: 3.0.4 + dev: true + /array-ify@1.0.0: resolution: {integrity: sha512-c5AMf34bKdvPhQ7tBGhqkgKNUzMr4WUs+WDtC2ZUGOUncbxKMTvqxYctiseW3+L4bA8ec+GcZ6/A/FW4m8ukng==} dev: true - /array-includes@3.1.5: - resolution: {integrity: sha512-iSDYZMMyTPkiFasVqfuAQnWAYcvO/SeBSCGKePoEthjp4LEMTe4uLc7b025o4jAZpHhihh8xPo99TNWUWWkGDQ==} + /array-includes@3.1.7: + resolution: {integrity: sha512-dlcsNBIiWhPkHdOEEKnehA+RNUWDc4UqFtnIXU4uuYDPtA4LDkr7qip2p0VvFAEXNDr0yWZ9PJyIRiGjRLQzwQ==} engines: {node: '>= 0.4'} dependencies: - call-bind: 1.0.5 - define-properties: 1.1.4 - es-abstract: 1.20.0 - get-intrinsic: 1.2.2 + call-bind: 1.0.7 + define-properties: 1.2.1 + es-abstract: 1.22.5 + get-intrinsic: 1.2.4 is-string: 1.0.7 dev: true @@ -3225,14 +3494,60 @@ packages: engines: {node: '>=0.10.0'} dev: true - /array.prototype.flat@1.3.0: - resolution: {integrity: sha512-12IUEkHsAhA4DY5s0FPgNXIdc8VRSqD9Zp78a5au9abH/SOBrsp082JOWFNTjkMozh8mqcdiKuaLGhPeYztxSw==} + /array.prototype.filter@1.0.3: + resolution: {integrity: sha512-VizNcj/RGJiUyQBgzwxzE5oHdeuXY5hSbbmKMlphj1cy1Vl7Pn2asCGbSrru6hSQjmCzqTBPVWAF/whmEOVHbw==} engines: {node: '>= 0.4'} dependencies: - call-bind: 1.0.5 - define-properties: 1.1.4 - es-abstract: 1.20.0 - es-shim-unscopables: 1.0.0 + call-bind: 1.0.7 + define-properties: 1.2.1 + es-abstract: 1.22.5 + es-array-method-boxes-properly: 1.0.0 + is-string: 1.0.7 + dev: true + + /array.prototype.findlastindex@1.2.4: + resolution: {integrity: sha512-hzvSHUshSpCflDR1QMUBLHGHP1VIEBegT4pix9H/Z92Xw3ySoy6c2qh7lJWTJnRJ8JCZ9bJNCgTyYaJGcJu6xQ==} + engines: {node: '>= 0.4'} + dependencies: + call-bind: 1.0.7 + define-properties: 1.2.1 + es-abstract: 1.22.5 + es-errors: 1.3.0 + es-shim-unscopables: 1.0.2 + dev: true + + /array.prototype.flat@1.3.2: + resolution: {integrity: sha512-djYB+Zx2vLewY8RWlNCUdHjDXs2XOgm602S9E7P/UpHgfeHL00cRiIF+IN/G/aUJ7kGPb6yO/ErDI5V2s8iycA==} + engines: {node: '>= 0.4'} + dependencies: + call-bind: 1.0.7 + define-properties: 1.2.1 + es-abstract: 1.22.5 + es-shim-unscopables: 1.0.2 + dev: true + + /array.prototype.flatmap@1.3.2: + resolution: {integrity: sha512-Ewyx0c9PmpcsByhSW4r+9zDU7sGjFc86qf/kKtuSCRdhfbk0SNLLkaT5qvcHnRGgc5NP/ly/y+qkXkqONX54CQ==} + engines: {node: '>= 0.4'} + dependencies: + call-bind: 1.0.7 + define-properties: 1.2.1 + es-abstract: 1.22.5 + es-shim-unscopables: 1.0.2 + dev: true + + /arraybuffer.prototype.slice@1.0.3: + resolution: {integrity: sha512-bMxMKAjg13EBSVscxTaYA4mRc5t1UAXa2kXiGTNfZ079HIWXEkKmkgFrh/nJqamaLSrXO5H4WFFkPEaLJWbs3A==} + engines: {node: '>= 0.4'} + dependencies: + array-buffer-byte-length: 1.0.1 + call-bind: 1.0.7 + define-properties: 1.2.1 + es-abstract: 1.22.5 + es-errors: 1.3.0 + get-intrinsic: 1.2.4 + is-array-buffer: 3.0.4 + is-shared-array-buffer: 1.0.3 dev: true /arrify@1.0.1: @@ -3326,6 +3641,13 @@ packages: hasBin: true dev: true + /available-typed-arrays@1.0.7: + resolution: {integrity: sha512-wvUjBtSGN7+7SjNpq/9M2Tg350UZD3q62IFZLbRAR1bSMlCo1ZaeW+BJ+D090e4hIIZLBcTDWe4Mh4jvUDajzQ==} + engines: {node: '>= 0.4'} + dependencies: + possible-typed-array-names: 1.0.0 + dev: true + /aws-sign2@0.7.0: resolution: {integrity: sha512-08kcGqnYf/YmjoRhfxyu+CLxBjUtHLXLXX/vUfx9l2LYzG3c1m61nrpyFUZI6zeS+Li/wWMMidD9KgrqtGq3mA==} @@ -3740,6 +4062,17 @@ packages: set-function-length: 1.1.1 dev: true + /call-bind@1.0.7: + resolution: {integrity: sha512-GHTSNSYICQ7scH7sZ+M2rFopRoLh8t2bLSW6BbgrtLsahOIB5iyAVJf9GjWK3cYTDaMj4XdBpM1cA6pIS0Kv2w==} + engines: {node: '>= 0.4'} + dependencies: + es-define-property: 1.0.0 + es-errors: 1.3.0 + function-bind: 1.1.2 + get-intrinsic: 1.2.4 + set-function-length: 1.2.2 + dev: true + /callsites@3.1.0: resolution: {integrity: sha512-P8BjAsXvZS+VIDUI11hHCQEv74YT67YUi5JJFNWIqL235sBmjX4+qx9Muvls5ivyNENctx46xQLQ3aTuE7ssaQ==} engines: {node: '>=6'} @@ -4040,7 +4373,7 @@ packages: natural-orderby: 2.0.3 object-treeify: 1.1.33 password-prompt: 1.1.2 - semver: 7.5.4 + semver: 7.6.0 string-width: 4.2.3 strip-ansi: 6.0.1 supports-color: 8.1.1 @@ -4195,6 +4528,11 @@ packages: engines: {node: '>=14'} dev: true + /commander@11.1.0: + resolution: {integrity: sha512-yPVavfyCcRhmorC7rWlkHn15b4wDVgVmBA7kV4QVBsF7kv/9TKJAbAXVTxvTnwP8HHKjRCJDClKbciiYS7p0DQ==} + engines: {node: '>=16'} + dev: true + /commander@2.20.3: resolution: {integrity: sha512-GpVkmM8vF2vQUkj2LvZmD35JxeJOLCwJ9cUkugyk2nuhbv3+mJvpLYYt+0+USMxE+oj+ey/lJEnhZw75x/OMcQ==} @@ -4691,24 +5029,25 @@ packages: clone: 1.0.4 dev: true - /define-data-property@1.1.1: - resolution: {integrity: sha512-E7uGkTzkk1d0ByLeSc6ZsFS79Axg+m1P/VsgYsxHgiuc3tFSj+MjMIwe90FC4lOAZzNBdY7kkO2P2wKdsQ1vgQ==} + /define-data-property@1.1.4: + resolution: {integrity: sha512-rBMvIzlpA8v6E+SJZoo++HAYqsLrkg7MSfIinMPFhmkorw7X+dOXVJQs+QT69zGkzMyfDnIMN2Wid1+NbL3T+A==} engines: {node: '>= 0.4'} dependencies: - get-intrinsic: 1.2.2 + es-define-property: 1.0.0 + es-errors: 1.3.0 gopd: 1.0.1 - has-property-descriptors: 1.0.1 dev: true /define-lazy-prop@2.0.0: resolution: {integrity: sha512-Ds09qNh8yw3khSjiJjiUInaGX9xlqZDY7JVryGxdxV7NPeuqQfplOpQ66yJFZut3jLa5zOwkXw1g9EI2uKh4Og==} engines: {node: '>=8'} - /define-properties@1.1.4: - resolution: {integrity: sha512-uckOqKcfaVvtBdsVkdPv3XjveQJsNQqmhXgRi8uhvWWuPYZCNlzT8qAyblUgNoXdHdjMTzAqeGjAoli8f+bzPA==} + /define-properties@1.2.1: + resolution: {integrity: sha512-8QmQKqEASLd5nx0U1B1okLElbUuuttJ/AnYmRXbbbGDWh6uS208EjD4Xqq/I9wK7u0v6O08XhTWnt5XtEbR6Dg==} engines: {node: '>= 0.4'} dependencies: - has-property-descriptors: 1.0.1 + define-data-property: 1.1.4 + has-property-descriptors: 1.0.2 object-keys: 1.1.1 dev: true @@ -5042,50 +5381,93 @@ packages: is-arrayish: 0.2.1 dev: true - /es-abstract@1.20.0: - resolution: {integrity: sha512-URbD8tgRthKD3YcC39vbvSDrX23upXnPcnGAjQfgxXF5ID75YcENawc9ZX/9iTP9ptUyfCLIxTTuMYoRfiOVKA==} + /es-abstract@1.22.5: + resolution: {integrity: sha512-oW69R+4q2wG+Hc3KZePPZxOiisRIqfKBVo/HLx94QcJeWGU/8sZhCvc829rd1kS366vlJbzBfXf9yWwf0+Ko7w==} engines: {node: '>= 0.4'} dependencies: - call-bind: 1.0.5 + array-buffer-byte-length: 1.0.1 + arraybuffer.prototype.slice: 1.0.3 + available-typed-arrays: 1.0.7 + call-bind: 1.0.7 + es-define-property: 1.0.0 + es-errors: 1.3.0 + es-set-tostringtag: 2.0.3 es-to-primitive: 1.2.1 - function-bind: 1.1.2 - function.prototype.name: 1.1.5 - get-intrinsic: 1.2.2 - get-symbol-description: 1.0.0 - has: 1.0.3 - has-property-descriptors: 1.0.1 + function.prototype.name: 1.1.6 + get-intrinsic: 1.2.4 + get-symbol-description: 1.0.2 + globalthis: 1.0.3 + gopd: 1.0.1 + has-property-descriptors: 1.0.2 + has-proto: 1.0.3 has-symbols: 1.0.3 - internal-slot: 1.0.3 - is-callable: 1.2.4 - is-negative-zero: 2.0.2 + hasown: 2.0.2 + internal-slot: 1.0.7 + is-array-buffer: 3.0.4 + is-callable: 1.2.7 + is-negative-zero: 2.0.3 is-regex: 1.1.4 - is-shared-array-buffer: 1.0.2 + is-shared-array-buffer: 1.0.3 is-string: 1.0.7 + is-typed-array: 1.1.13 is-weakref: 1.0.2 object-inspect: 1.13.1 object-keys: 1.1.1 - object.assign: 4.1.2 - regexp.prototype.flags: 1.4.3 - string.prototype.trimend: 1.0.5 - string.prototype.trimstart: 1.0.5 + object.assign: 4.1.5 + regexp.prototype.flags: 1.5.2 + safe-array-concat: 1.1.2 + safe-regex-test: 1.0.3 + string.prototype.trim: 1.2.8 + string.prototype.trimend: 1.0.7 + string.prototype.trimstart: 1.0.7 + typed-array-buffer: 1.0.2 + typed-array-byte-length: 1.0.1 + typed-array-byte-offset: 1.0.2 + typed-array-length: 1.0.5 unbox-primitive: 1.0.2 + which-typed-array: 1.1.15 + dev: true + + /es-array-method-boxes-properly@1.0.0: + resolution: {integrity: sha512-wd6JXUmyHmt8T5a2xreUwKcGPq6f1f+WwIJkijUqiGcJz1qqnZgP6XIK+QyIWU5lT7imeNxUll48bziG+TSYcA==} + dev: true + + /es-define-property@1.0.0: + resolution: {integrity: sha512-jxayLKShrEqqzJ0eumQbVhTYQM27CfT1T35+gCgDFoL82JLsXqTJ76zv6A0YLOgEnLUMvLzsDsGIrl8NFpT2gQ==} + engines: {node: '>= 0.4'} + dependencies: + get-intrinsic: 1.2.4 + dev: true + + /es-errors@1.3.0: + resolution: {integrity: sha512-Zf5H2Kxt2xjTvbJvP2ZWLEICxA6j+hAmMzIlypy4xcBg1vKVnx89Wy0GbS+kf5cwCVFFzdCFh2XSCFNULS6csw==} + engines: {node: '>= 0.4'} dev: true /es-module-lexer@1.3.0: resolution: {integrity: sha512-vZK7T0N2CBmBOixhmjdqx2gWVbFZ4DXZ/NyRMZVlJXPa7CyFS+/a4QQsDGDQy9ZfEzxFuNEsMLeQJnKP2p5/JA==} dev: true - /es-shim-unscopables@1.0.0: - resolution: {integrity: sha512-Jm6GPcCdC30eMLbZ2x8z2WuRwAws3zTBBKuusffYVUrNj/GVSUAZ+xKMaUpfNDR5IbyNA5LJbaecoUVbmUcB1w==} + /es-set-tostringtag@2.0.3: + resolution: {integrity: sha512-3T8uNMC3OQTHkFUsFq8r/BwAXLHvU/9O9mE0fBc/MY5iq/8H7ncvO947LmYA6ldWw9Uh8Yhf25zu6n7nML5QWQ==} + engines: {node: '>= 0.4'} + dependencies: + get-intrinsic: 1.2.4 + has-tostringtag: 1.0.2 + hasown: 2.0.2 + dev: true + + /es-shim-unscopables@1.0.2: + resolution: {integrity: sha512-J3yBRXCzDu4ULnQwxyToo/OjdMx6akgVC7K6few0a7F/0wLtmKKN7I73AH5T2836UuXRqN7Qg+IIUw/+YJksRw==} dependencies: - has: 1.0.3 + hasown: 2.0.2 dev: true /es-to-primitive@1.2.1: resolution: {integrity: sha512-QCOllgZJtaUo9miYBcLChTUaHNjJF3PYs1VidD7AwiEj1kYxKeQTctLAezAOH5ZKRH0g2IgPn6KwB4IT8iRpvA==} engines: {node: '>= 0.4'} dependencies: - is-callable: 1.2.4 + is-callable: 1.2.7 is-date-object: 1.0.5 is-symbol: 1.0.4 dev: true @@ -5165,35 +5547,39 @@ packages: source-map: 0.6.1 dev: false - /eslint-config-prettier@8.5.0(eslint@8.19.0): - resolution: {integrity: sha512-obmWKLUNCnhtQRKc+tmnYuQl0pFU1ibYJQ5BGhTVB08bHe9wC8qUeG7c08dj9XX+AuPj1YSGSQIHl1pnDHZR0Q==} + /eslint-config-prettier@8.10.0(eslint@8.57.0): + resolution: {integrity: sha512-SM8AMJdeQqRYT9O9zguiruQZaN7+z+E4eAP9oiLNGKMtomwaB1E9dcgUD6ZAn/eQAb52USbvezbiljfZUhbJcg==} hasBin: true peerDependencies: eslint: '>=7.0.0' dependencies: - eslint: 8.19.0 + eslint: 8.57.0 dev: true - /eslint-import-resolver-node@0.3.6: - resolution: {integrity: sha512-0En0w03NRVMn9Uiyn8YRPDKvWjxCWkslUEhGNTdGx15RvPJYQ+lbOlqrlNI2vEAs4pDYK4f/HN2TbDmk5TP0iw==} + /eslint-import-resolver-node@0.3.9: + resolution: {integrity: sha512-WFj2isz22JahUv+B788TlO3N6zL3nNJGU8CcZbPZvVEkBPaJdCV4vy5wyghty5ROFbCRnm132v8BScu5/1BQ8g==} dependencies: debug: 3.2.7(supports-color@5.5.0) + is-core-module: 2.13.1 resolve: 1.22.8 transitivePeerDependencies: - supports-color dev: true - /eslint-module-utils@2.7.3(@typescript-eslint/parser@5.30.6)(eslint-import-resolver-node@0.3.6): - resolution: {integrity: sha512-088JEC7O3lDZM9xGe0RerkOMd0EjFl+Yvd1jPWIkMT5u3H9+HC34mWWPnqPrN13gieT9pBOO+Qt07Nb/6TresQ==} + /eslint-module-utils@2.8.1(@typescript-eslint/parser@5.62.0)(eslint-import-resolver-node@0.3.9)(eslint@8.57.0): + resolution: {integrity: sha512-rXDXR3h7cs7dy9RNpUlQf80nX31XWJEyGq1tRMo+6GsO5VmTe4UTwtmonAD4ZkAsrfMVDA2wlGJ3790Ys+D49Q==} engines: {node: '>=4'} peerDependencies: '@typescript-eslint/parser': '*' + eslint: '*' eslint-import-resolver-node: '*' eslint-import-resolver-typescript: '*' eslint-import-resolver-webpack: '*' peerDependenciesMeta: '@typescript-eslint/parser': optional: true + eslint: + optional: true eslint-import-resolver-node: optional: true eslint-import-resolver-typescript: @@ -5201,16 +5587,16 @@ packages: eslint-import-resolver-webpack: optional: true dependencies: - '@typescript-eslint/parser': 5.30.6(eslint@8.19.0)(typescript@5.1.6) + '@typescript-eslint/parser': 5.62.0(eslint@8.57.0)(typescript@5.1.6) debug: 3.2.7(supports-color@5.5.0) - eslint-import-resolver-node: 0.3.6 - find-up: 2.1.0 + eslint: 8.57.0 + eslint-import-resolver-node: 0.3.9 transitivePeerDependencies: - supports-color dev: true - /eslint-plugin-import@2.26.0(@typescript-eslint/parser@5.30.6)(eslint@8.19.0): - resolution: {integrity: sha512-hYfi3FXaM8WPLf4S1cikh/r4IxnO6zrhZbEGz2b660EJRbuxgpDS5gkCuYgGWg2xxh2rBuIr4Pvhve/7c31koA==} + /eslint-plugin-import@2.29.1(@typescript-eslint/parser@5.62.0)(eslint@8.57.0): + resolution: {integrity: sha512-BbPC0cuExzhiMo4Ff1BTVwHpjjv28C5R+btTOGaCRC7UEz801up0JadwkeSk5Ued6TG34uaczuVuH6qyy5YUxw==} engines: {node: '>=4'} peerDependencies: '@typescript-eslint/parser': '*' @@ -5219,28 +5605,32 @@ packages: '@typescript-eslint/parser': optional: true dependencies: - '@typescript-eslint/parser': 5.30.6(eslint@8.19.0)(typescript@5.1.6) - array-includes: 3.1.5 - array.prototype.flat: 1.3.0 - debug: 2.6.9(supports-color@3.2.3) + '@typescript-eslint/parser': 5.62.0(eslint@8.57.0)(typescript@5.1.6) + array-includes: 3.1.7 + array.prototype.findlastindex: 1.2.4 + array.prototype.flat: 1.3.2 + array.prototype.flatmap: 1.3.2 + debug: 3.2.7(supports-color@5.5.0) doctrine: 2.1.0 - eslint: 8.19.0 - eslint-import-resolver-node: 0.3.6 - eslint-module-utils: 2.7.3(@typescript-eslint/parser@5.30.6)(eslint-import-resolver-node@0.3.6) - has: 1.0.3 + eslint: 8.57.0 + eslint-import-resolver-node: 0.3.9 + eslint-module-utils: 2.8.1(@typescript-eslint/parser@5.62.0)(eslint-import-resolver-node@0.3.9)(eslint@8.57.0) + hasown: 2.0.2 is-core-module: 2.13.1 is-glob: 4.0.3 minimatch: 3.1.2 - object.values: 1.1.5 - resolve: 1.22.8 - tsconfig-paths: 3.14.1 + object.fromentries: 2.0.7 + object.groupby: 1.0.2 + object.values: 1.1.7 + semver: 6.3.1 + tsconfig-paths: 3.15.0 transitivePeerDependencies: - eslint-import-resolver-typescript - eslint-import-resolver-webpack - supports-color dev: true - /eslint-plugin-jsdoc@37.9.7(eslint@8.19.0): + /eslint-plugin-jsdoc@37.9.7(eslint@8.57.0): resolution: {integrity: sha512-8alON8yYcStY94o0HycU2zkLKQdcS+qhhOUNQpfONHHwvI99afbmfpYuPqf6PbLz5pLZldG3Te5I0RbAiTN42g==} engines: {node: ^12 || ^14 || ^16 || ^17} peerDependencies: @@ -5250,7 +5640,7 @@ packages: comment-parser: 1.3.0 debug: 4.3.4(supports-color@8.1.1) escape-string-regexp: 4.0.0 - eslint: 8.19.0 + eslint: 8.57.0 esquery: 1.4.0 regextras: 0.8.0 semver: 7.5.4 @@ -5259,17 +5649,17 @@ packages: - supports-color dev: true - /eslint-plugin-prefer-arrow@1.2.3(eslint@8.19.0): + /eslint-plugin-prefer-arrow@1.2.3(eslint@8.57.0): resolution: {integrity: sha512-J9I5PKCOJretVuiZRGvPQxCbllxGAV/viI20JO3LYblAodofBxyMnZAJ+WGeClHgANnSJberTNoFWWjrWKBuXQ==} peerDependencies: eslint: '>=2.0.0' dependencies: - eslint: 8.19.0 + eslint: 8.57.0 dev: true - /eslint-plugin-prettier@4.0.0(eslint-config-prettier@8.5.0)(eslint@8.19.0)(prettier@2.6.2): - resolution: {integrity: sha512-98MqmCJ7vJodoQK359bqQWaxOE0CS8paAz/GgjaZLyex4TTk3g9HugoO89EqWCrFiOqn9EVvcoo7gZzONCWVwQ==} - engines: {node: '>=6.0.0'} + /eslint-plugin-prettier@4.2.1(eslint-config-prettier@8.10.0)(eslint@8.57.0)(prettier@2.6.2): + resolution: {integrity: sha512-f/0rXLXUt0oFYs8ra4w49wYZBG5GKZpAYsJSm6rnYL5uVDjd+zowwMwVZHnAjf4edNrKpCDYfXDgmRE/Ak7QyQ==} + engines: {node: '>=12.0.0'} peerDependencies: eslint: '>=7.28.0' eslint-config-prettier: '*' @@ -5278,8 +5668,8 @@ packages: eslint-config-prettier: optional: true dependencies: - eslint: 8.19.0 - eslint-config-prettier: 8.5.0(eslint@8.19.0) + eslint: 8.57.0 + eslint-config-prettier: 8.10.0(eslint@8.57.0) prettier: 2.6.2 prettier-linter-helpers: 1.0.0 dev: true @@ -5292,85 +5682,73 @@ packages: estraverse: 4.3.0 dev: true - /eslint-scope@7.1.1: - resolution: {integrity: sha512-QKQM/UXpIiHcLqJ5AOyIW7XZmzjkzQXYE54n1++wb0u9V/abW3l9uQnxX8Z5Xd18xyKIMTUAyQ0k1e8pz6LUrw==} + /eslint-scope@7.2.2: + resolution: {integrity: sha512-dOt21O7lTMhDM+X9mB4GX+DZrZtCUJPL/wlcTqxyrx5IvO0IYtILdtrQGQp+8n5S0gwSVmOf9NQrjMOgfQZlIg==} engines: {node: ^12.22.0 || ^14.17.0 || >=16.0.0} dependencies: esrecurse: 4.3.0 estraverse: 5.3.0 dev: true - /eslint-utils@3.0.0(eslint@8.19.0): - resolution: {integrity: sha512-uuQC43IGctw68pJA1RgbQS8/NP7rch6Cwd4j3ZBtgo4/8Flj4eGE7ZYSZRN3iq5pVUv6GPdW5Z1RFleo84uLDA==} - engines: {node: ^10.0.0 || ^12.0.0 || >= 14.0.0} - peerDependencies: - eslint: '>=5' - dependencies: - eslint: 8.19.0 - eslint-visitor-keys: 2.1.0 - dev: true - - /eslint-visitor-keys@2.1.0: - resolution: {integrity: sha512-0rSmRBzXgDzIsD6mGdJgevzgezI534Cer5L/vyMX0kHzT/jiB43jRhd9YUlMGYLQy2zprNmoT8qasCGtY+QaKw==} - engines: {node: '>=10'} - dev: true - - /eslint-visitor-keys@3.3.0: - resolution: {integrity: sha512-mQ+suqKJVyeuwGYHAdjMFqjCyfl8+Ldnxuyp3ldiMBFKkvytrXUZWaiPCEav8qDHKty44bD+qV1IP4T+w+xXRA==} + /eslint-visitor-keys@3.4.3: + resolution: {integrity: sha512-wpc+LXeiyiisxPlEkUzU6svyS1frIO3Mgxj1fdy7Pm8Ygzguax2N3Fa/D/ag1WqbOprdI+uY6wMUl8/a2G+iag==} engines: {node: ^12.22.0 || ^14.17.0 || >=16.0.0} dev: true - /eslint@8.19.0: - resolution: {integrity: sha512-SXOPj3x9VKvPe81TjjUJCYlV4oJjQw68Uek+AM0X4p+33dj2HY5bpTZOgnQHcG2eAm1mtCU9uNMnJi7exU/kYw==} + /eslint@8.57.0: + resolution: {integrity: sha512-dZ6+mexnaTIbSBZWgou51U6OmzIhYM2VcNdtiTtI7qPNZm35Akpr0f6vtw3w1Kmn5PYo+tZVfh13WrhpS6oLqQ==} engines: {node: ^12.22.0 || ^14.17.0 || >=16.0.0} hasBin: true dependencies: - '@eslint/eslintrc': 1.3.0 - '@humanwhocodes/config-array': 0.9.5 + '@eslint-community/eslint-utils': 4.4.0(eslint@8.57.0) + '@eslint-community/regexpp': 4.10.0 + '@eslint/eslintrc': 2.1.4 + '@eslint/js': 8.57.0 + '@humanwhocodes/config-array': 0.11.14 + '@humanwhocodes/module-importer': 1.0.1 + '@nodelib/fs.walk': 1.2.8 + '@ungap/structured-clone': 1.2.0 ajv: 6.12.6 chalk: 4.1.2 cross-spawn: 7.0.3 debug: 4.3.4(supports-color@8.1.1) doctrine: 3.0.0 escape-string-regexp: 4.0.0 - eslint-scope: 7.1.1 - eslint-utils: 3.0.0(eslint@8.19.0) - eslint-visitor-keys: 3.3.0 - espree: 9.3.2 - esquery: 1.4.0 + eslint-scope: 7.2.2 + eslint-visitor-keys: 3.4.3 + espree: 9.6.1 + esquery: 1.5.0 esutils: 2.0.3 fast-deep-equal: 3.1.3 file-entry-cache: 6.0.1 - functional-red-black-tree: 1.0.1 + find-up: 5.0.0 glob-parent: 6.0.2 - globals: 13.16.0 + globals: 13.24.0 + graphemer: 1.4.0 ignore: 5.2.0 - import-fresh: 3.3.0 imurmurhash: 0.1.4 is-glob: 4.0.3 + is-path-inside: 3.0.3 js-yaml: 4.1.0 json-stable-stringify-without-jsonify: 1.0.1 levn: 0.4.1 lodash.merge: 4.6.2 minimatch: 3.1.2 natural-compare: 1.4.0 - optionator: 0.9.1 - regexpp: 3.2.0 + optionator: 0.9.3 strip-ansi: 6.0.1 - strip-json-comments: 3.1.1 text-table: 0.2.0 - v8-compile-cache: 2.3.0 transitivePeerDependencies: - supports-color dev: true - /espree@9.3.2: - resolution: {integrity: sha512-D211tC7ZwouTIuY5x9XnS0E9sWNChB7IYKX/Xp5eQj3nFXhqmiUDB9q27y76oFl8jTg3pXcQx/bpxMfs3CIZbA==} + /espree@9.6.1: + resolution: {integrity: sha512-oruZaFkjorTpF32kDSI5/75ViwGeZginGGy2NoOSg3Q9bnwlnmDm4HLnkl0RE3n+njDXR037aY1+x58Z/zFdwQ==} engines: {node: ^12.22.0 || ^14.17.0 || >=16.0.0} dependencies: - acorn: 8.10.0 - acorn-jsx: 5.3.2(acorn@8.10.0) - eslint-visitor-keys: 3.3.0 + acorn: 8.11.3 + acorn-jsx: 5.3.2(acorn@8.11.3) + eslint-visitor-keys: 3.4.3 dev: true /esprima@4.0.1: @@ -5385,6 +5763,13 @@ packages: estraverse: 5.3.0 dev: true + /esquery@1.5.0: + resolution: {integrity: sha512-YQLXUplAwJgCydQ78IMJywZCceoqk1oH01OERdSAJc/7U2AylwjhSCLDEtqwg811idIS/9fIU5GjG73IgjKMVg==} + engines: {node: '>=0.10'} + dependencies: + estraverse: 5.3.0 + dev: true + /esrecurse@4.3.0: resolution: {integrity: sha512-KmfKL3b6G+RXvP8N1vr3Tq1kL/oCFgn2NYXEtqP8/L3pKapUA4G8cFVaoF3SU323CD4XypR/ffioHmkti6/Tag==} engines: {node: '>=4.0'} @@ -5653,8 +6038,8 @@ packages: resolution: {integrity: sha512-On2N+BpYJ15xIC974QNVuYGMOlEVt4s0EOI3wwMqOmK1fdDY+FN/zltPV8vosq4ad4c/gJ1KHScUn/6AWIgiow==} dev: true - /fastq@1.13.0: - resolution: {integrity: sha512-YpkpUnK8od0o1hmeSc7UUs/eB/vIPWJYjKck2QKIzAf71Vm1AAQ3EbuZB3g2JIy+pg+ERD0vqI79KyZiB2e2Nw==} + /fastq@1.17.1: + resolution: {integrity: sha512-sRVD3lWVIXWg6By68ZN7vho9a1pQcN/WBFaAAsDDFzlJjvoGx0P8z7V1t72grFJfJhu3YPZBuu25f7Kaw2jN1w==} dependencies: reusify: 1.0.4 @@ -5773,6 +6158,14 @@ packages: path-exists: 4.0.0 dev: true + /find-up@5.0.0: + resolution: {integrity: sha512-78/PXT1wlLLDgTzDs7sjq9hzz0vXD+zn+7wypEe4fXQxCmdmqfGsEPQxmiCSQI3ajFV91bVSsvNtrJRiW6nGng==} + engines: {node: '>=10'} + dependencies: + locate-path: 6.0.0 + path-exists: 4.0.0 + dev: true + /flat-cache@3.0.4: resolution: {integrity: sha512-dm9s5Pw7Jc0GvMYbshN6zchCA9RgQlzzEZX3vylR9IqFfS8XciblUXOKfW6SiuJ0e13eDYZoZV5wdrev7P3Nwg==} engines: {node: ^10.12.0 || >=12.0.0} @@ -5797,6 +6190,12 @@ packages: debug: 3.2.7(supports-color@5.5.0) dev: true + /for-each@0.3.3: + resolution: {integrity: sha512-jqYfLp7mo9vIyQf8ykW2v7A+2N4QjeCeI5+Dz9XraiO1ign81wjiH7Fb9vSOWvQfNtmSa4H2RoQTrrXivdUZmw==} + dependencies: + is-callable: 1.2.7 + dev: true + /for-in@1.0.2: resolution: {integrity: sha512-7EwmXrOjyL+ChxMhmG5lnW9MPt1aIeZEwKhQzoBUdTV0N3zuwWDZYVJatDvZ2OyzPUvdIAZDsCetk3coyMfcnQ==} engines: {node: '>=0.10.0'} @@ -5875,7 +6274,7 @@ packages: requiresBuild: true dependencies: bindings: 1.5.0 - nan: 2.18.0 + nan: 2.19.0 dev: true optional: true @@ -5899,20 +6298,16 @@ packages: /function-bind@1.1.2: resolution: {integrity: sha512-7XHNxH7qX9xG5mIwxkhumTox/MIRNcOgDrxWsMt2pAr23WHp6MrRlN7FBSFpCpr+oVO0F744iUgR82nJMfG2SA==} - /function.prototype.name@1.1.5: - resolution: {integrity: sha512-uN7m/BzVKQnCUF/iW8jYea67v++2u7m5UgENbHRtdDVclOUP+FMPlCNdmk0h/ysGyo2tavMJEDqJAkJdRa1vMA==} + /function.prototype.name@1.1.6: + resolution: {integrity: sha512-Z5kx79swU5P27WEayXM1tBi5Ze/lbIyiNgU3qyXUOf9b2rgXYyF9Dy9Cx+IQv/Lc8WCG6L82zwUPpSS9hGehIg==} engines: {node: '>= 0.4'} dependencies: - call-bind: 1.0.5 - define-properties: 1.1.4 - es-abstract: 1.20.0 + call-bind: 1.0.7 + define-properties: 1.2.1 + es-abstract: 1.22.5 functions-have-names: 1.2.3 dev: true - /functional-red-black-tree@1.0.1: - resolution: {integrity: sha512-dsKNQNdj6xA3T+QlADDA7mOSlX0qiMINjn0cgr+eGHGsbSHzTabcIogz2+p/iqP1Xs6EP/sS2SbqH+brGTbq0g==} - dev: true - /functions-have-names@1.2.3: resolution: {integrity: sha512-xckBUXyTIqT97tq2x2AMb+g163b5JFysYk0x4qxNFwbfQkmNZoiRHb6sPzI9/QV33WeuvVYBUIiD4NzNIyqaRQ==} dev: true @@ -5947,7 +6342,18 @@ packages: function-bind: 1.1.2 has-proto: 1.0.1 has-symbols: 1.0.3 - hasown: 2.0.0 + hasown: 2.0.2 + dev: true + + /get-intrinsic@1.2.4: + resolution: {integrity: sha512-5uYhsJH8VJBTv7oslg4BznJYhDoRI6waYCxMmCdnTrcCrHA/fCFKoTFz2JKKE0HdDFUF7/oQuhzumXJK7paBRQ==} + engines: {node: '>= 0.4'} + dependencies: + es-errors: 1.3.0 + function-bind: 1.1.2 + has-proto: 1.0.3 + has-symbols: 1.0.3 + hasown: 2.0.2 dev: true /get-package-type@0.1.0: @@ -5983,12 +6389,13 @@ packages: engines: {node: '>=10'} dev: true - /get-symbol-description@1.0.0: - resolution: {integrity: sha512-2EmdH1YvIQiZpltCNgkuiUnyukzxM/R6NDJX31Ke3BG1Nq5b0S2PhX59UKi9vZpPDQVdqn+1IcaAwnzTT5vCjw==} + /get-symbol-description@1.0.2: + resolution: {integrity: sha512-g0QYk1dZBxGwk+Ngc+ltRH2IBp2f7zBkBMBJZCDerh6EhlhSR6+9irMCuT/09zD6qkarHUSn529sK/yL4S27mg==} engines: {node: '>= 0.4'} dependencies: - call-bind: 1.0.5 - get-intrinsic: 1.2.2 + call-bind: 1.0.7 + es-errors: 1.3.0 + get-intrinsic: 1.2.4 dev: true /get-tsconfig@4.7.0: @@ -6144,13 +6551,20 @@ packages: engines: {node: '>=4'} dev: true - /globals@13.16.0: - resolution: {integrity: sha512-A1lrQfpNF+McdPOnnFqY3kSN0AFTy485bTi1bkLk4mVPODIUEcSfhHgRqA+QdXPksrSTTztYXx37NFV+GpGk3Q==} + /globals@13.24.0: + resolution: {integrity: sha512-AhO5QUcj8llrbG09iWhPU2B204J1xnPeL8kQmVorSsy+Sjj1sk8gIyh6cUocGmH4L0UuhAJy+hJMRA4mgA4mFQ==} engines: {node: '>=8'} dependencies: type-fest: 0.20.2 dev: true + /globalthis@1.0.3: + resolution: {integrity: sha512-sFdI5LyBiNTHjRd7cGPWapiHWMOXKyuBNX/cWJ3NfzrZQVa8GI/8cofCl74AOVqq9W5kNmguTIzJ/1s2gyI9wA==} + engines: {node: '>= 0.4'} + dependencies: + define-properties: 1.2.1 + dev: true + /globby@11.1.0: resolution: {integrity: sha512-jhIXaOzy1sb8IyocaruWSn1TjmnBVs8Ayhcy83rmxNJ8q2uWKCAj3CnJY+KpGSXCueAPc0i05kVvVKtP1t9S3g==} engines: {node: '>=10'} @@ -6165,7 +6579,7 @@ packages: /gopd@1.0.1: resolution: {integrity: sha512-d65bNlIadxvpb/A2abVdlqKqV563juRnZ1Wtk6s1sIR8uNsXR70xqIzVqxVf1eTqDunwT2MkczEeaezCKTZhwA==} dependencies: - get-intrinsic: 1.2.2 + get-intrinsic: 1.2.4 dev: true /got@8.3.2: @@ -6196,6 +6610,10 @@ packages: /graceful-fs@4.2.11: resolution: {integrity: sha512-RbJ5/jmFcNNCcDV5o9eTnBLJ/HszWV0P73bc+Ff4nS/rJj+YaS6IGyiOL0VoBYX+l1Wrl3k63h/KrH+nhJ0XvQ==} + /graphemer@1.4.0: + resolution: {integrity: sha512-EtKwoO6kxCL9WO5xipiHTZlSzBm7WLT627TqC/uVRd0HKmq8NXyebnNYxDoBi7wt8eTWrUrKXCOVaFq9x1kgag==} + dev: true + /handlebars@4.7.7: resolution: {integrity: sha512-aAcXm5OAfE/8IXkcZvCepKU3VzW1/39Fb5ZuqMtgI/hT8X2YgoMvBY5dLhq/cpOvw7Lk1nK/UF71aLG/ZnVYRA==} engines: {node: '>=0.4.7'} @@ -6248,10 +6666,10 @@ packages: resolution: {integrity: sha512-EykJT/Q1KjTWctppgIAgfSO0tKVuZUjhgMr17kqTumMl6Afv3EISleU7qZUzoXDFTAHTDC4NOoG/ZxU3EvlMPQ==} engines: {node: '>=8'} - /has-property-descriptors@1.0.1: - resolution: {integrity: sha512-VsX8eaIewvas0xnvinAe9bw4WfIeODpGYikiWYLH+dma0Jw6KHYqWiWfhQlgOVK8D6PvjubK5Uc4P0iIhIcNVg==} + /has-property-descriptors@1.0.2: + resolution: {integrity: sha512-55JNKuIW+vq4Ke1BjOTjM2YctQIvCT7GFzHwmfZPGo5wnrgkid0YQtnAleFSqumZm4az3n2BS+erby5ipJdgrg==} dependencies: - get-intrinsic: 1.2.2 + es-define-property: 1.0.0 dev: true /has-proto@1.0.1: @@ -6259,6 +6677,11 @@ packages: engines: {node: '>= 0.4'} dev: true + /has-proto@1.0.3: + resolution: {integrity: sha512-SJ1amZAJUiZS+PhsVLf5tGydlaVB8EdFpaSO4gmiUKUOxk8qzn5AIy4ZeJUmh22znIdk/uMAUT2pl3FxzVUH+Q==} + engines: {node: '>= 0.4'} + dev: true + /has-symbol-support-x@1.4.2: resolution: {integrity: sha512-3ToOva++HaW+eCpgqZrCfN51IPB+7bJNVT6CUATzueB5Heb8o6Nam0V3HG5dlDvZU1Gn5QLcbahiKw/XVk5JJw==} dev: true @@ -6274,8 +6697,8 @@ packages: has-symbol-support-x: 1.4.2 dev: true - /has-tostringtag@1.0.0: - resolution: {integrity: sha512-kFjcSNhnlGV1kyoGk7OXKSawH5JOb/LzUc5w9B02hOTO0dfFRjbHQKvg1d6cf3HbeUmtU9VbbV3qzZ2Teh97WQ==} + /has-tostringtag@1.0.2: + resolution: {integrity: sha512-NqADB8VjPFLM2V0VvHUewwwsw0ZWBaIdgo+ieHtK3hasLz4qeCRjYcqfB6AQrBggRKppKF8L52/VqdVsO47Dlw==} engines: {node: '>= 0.4'} dependencies: has-symbols: 1.0.3 @@ -6316,15 +6739,8 @@ packages: kind-of: 4.0.0 dev: true - /has@1.0.3: - resolution: {integrity: sha512-f2dvO0VU6Oej7RkWJGrehjbzMAjFp5/VKPp5tTpWIV4JHHZK1/BxbFRtf/siA2SWTe09caDmVtYYzWEIbBS4zw==} - engines: {node: '>= 0.4.0'} - dependencies: - function-bind: 1.1.2 - dev: true - - /hasown@2.0.0: - resolution: {integrity: sha512-vUptKVTpIJhcczKBbgnS+RtcuYMB8+oNzPK2/Hp3hanz8JmpATdmmgLgSaadVREkDm+e2giHwY3ZRkyjSIDDFA==} + /hasown@2.0.2: + resolution: {integrity: sha512-0hJU9SCPvmMzIBdZFqNPXWa6dqh7WdH0cII9y+CyS8rG3nL48Bclra9HmKhVVUHyPWNH5Y7xDwAB7bfgSjkUMQ==} engines: {node: '>= 0.4'} dependencies: function-bind: 1.1.2 @@ -6639,13 +7055,13 @@ packages: wrap-ansi: 7.0.0 dev: true - /internal-slot@1.0.3: - resolution: {integrity: sha512-O0DB1JC/sPyZl7cIo78n5dR7eUSwwpYPiXRhTzNxZVAMUuB8vlnRFyLxdrVToks6XPLVnFfbzaVd5WLjhgg+vA==} + /internal-slot@1.0.7: + resolution: {integrity: sha512-NGnrKwXzSms2qUUih/ILZ5JBqNTSa1+ZmP6flaIp6KmSElgE9qdndzS3cqjrDovwFdmwsGsLdeFgB6suw+1e9g==} engines: {node: '>= 0.4'} dependencies: - get-intrinsic: 1.2.2 - has: 1.0.3 - side-channel: 1.0.4 + es-errors: 1.3.0 + hasown: 2.0.2 + side-channel: 1.0.6 dev: true /interpret@0.6.6: @@ -6687,6 +7103,14 @@ packages: kind-of: 6.0.3 dev: true + /is-array-buffer@3.0.4: + resolution: {integrity: sha512-wcjaerHw0ydZwfhiKbXJWLDY8A7yV7KhjQOpb83hGgGfId/aQa4TOvwyzn2PuswW2gPCYEL/nEAiSVpdOj1lXw==} + engines: {node: '>= 0.4'} + dependencies: + call-bind: 1.0.7 + get-intrinsic: 1.2.4 + dev: true + /is-arrayish@0.2.1: resolution: {integrity: sha512-zz06S8t0ozoDXMG+ube26zeCTNXcKIPJZJi8hBrF4idCLms4CG9QtK7qBl1boi5ODzFpjswb5JPmHCbMpjaYzg==} dev: true @@ -6715,16 +7139,16 @@ packages: resolution: {integrity: sha512-gDYaKHJmnj4aWxyj6YHyXVpdQawtVLHU5cb+eztPGczf6cjuTdwve5ZIEfgXqH4e57An1D1AKf8CZ3kYrQRqYA==} engines: {node: '>= 0.4'} dependencies: - call-bind: 1.0.5 - has-tostringtag: 1.0.0 + call-bind: 1.0.7 + has-tostringtag: 1.0.2 dev: true /is-buffer@1.1.6: resolution: {integrity: sha512-NcdALwpXkTm5Zvvbk7owOUSvVvBKDgKP5/ewfXEznmQFfs4ZRmanOeKBTjRVjka3QFoN6XJ+9F3USqfHqTaU5w==} dev: true - /is-callable@1.2.4: - resolution: {integrity: sha512-nsuwtxZfMX67Oryl9LCQ+upnC0Z0BgpwntpS89m1H/TLF0zNfzfLMV/9Wa/6MZsj0acpEjAO0KF1xT6ZdLl95w==} + /is-callable@1.2.7: + resolution: {integrity: sha512-1BC0BVFhS/p0qtw6enp8e+8OD0UrK0oFLztSjNzhcKA3WDuJxxAPXzPuPtKkjEY9UUoEWlX/8fgKeu2S8i9JTA==} engines: {node: '>= 0.4'} dev: true @@ -6738,7 +7162,7 @@ packages: /is-core-module@2.13.1: resolution: {integrity: sha512-hHrIjvZsftOsvKSn2TRYl63zvxsgE0K+0mYMoH6gD4omR5IWB2KynivBQczo3+wF1cCkjzvptnI9Q0sPU66ilw==} dependencies: - hasown: 2.0.0 + hasown: 2.0.2 /is-data-descriptor@0.1.4: resolution: {integrity: sha512-+w9D5ulSoBNlmw9OHn3U2v51SyoCd0he+bB3xMl62oijhrspxowjU+AIcDY0N3iEJbUEkB15IlMASQsxYigvXg==} @@ -6758,7 +7182,7 @@ packages: resolution: {integrity: sha512-9YQaSxsAiSwcvS33MBk3wTCVnWK+HhF8VZR2jRxehM16QcVOdHqPn4VPHmRK4lSr38n9JriurInLcP90xsYNfQ==} engines: {node: '>= 0.4'} dependencies: - has-tostringtag: 1.0.0 + has-tostringtag: 1.0.2 dev: true /is-descriptor@0.1.6: @@ -6865,8 +7289,8 @@ packages: resolution: {integrity: sha512-z7CMFGNrENq5iFB9Bqo64Xk6Y9sg+epq1myIcdHaGnbMTYOxvzsEtdYqQUylB7LxfkvgrrjP32T6Ywciio9UIQ==} dev: true - /is-negative-zero@2.0.2: - resolution: {integrity: sha512-dqJvarLawXsFbNDeJW7zAz8ItJ9cd28YufuuFzh0G8pNHjJMnY08Dv7sYX2uF5UpQOwieAeOExEYAWWfu7ZZUA==} + /is-negative-zero@2.0.3: + resolution: {integrity: sha512-5KoIu2Ngpyek75jXodFvnafB6DJgr3u8uuK0LEZJjrU19DrMD3EVERaR8sjz8CCGgpZvxPl9SuE1GMVPFHx1mw==} engines: {node: '>= 0.4'} dev: true @@ -6874,7 +7298,7 @@ packages: resolution: {integrity: sha512-k1U0IRzLMo7ZlYIfzRu23Oh6MiIFasgpb9X76eqfFZAqwH44UI4KTBvBYIZ1dSL9ZzChTB9ShHfLkR4pdW5krQ==} engines: {node: '>= 0.4'} dependencies: - has-tostringtag: 1.0.0 + has-tostringtag: 1.0.2 dev: true /is-number@2.1.0: @@ -6909,6 +7333,11 @@ packages: resolution: {integrity: sha512-2rRIahhZr2UWb45fIOuvZGpFtz0TyOZLf32KxBbSoUCeZR495zCKlWUKKUByk3geS2eAs7ZAABt0Y/Rx0GiQGA==} dev: true + /is-path-inside@3.0.3: + resolution: {integrity: sha512-Fd4gABb+ycGAmKou8eMftCupSir5lRxqf4aD/vd0cD2qc4HL07OjCeuHMr8Ro4CoMaeCKDB0/ECBOVWjTwUvPQ==} + engines: {node: '>=8'} + dev: true + /is-plain-obj@1.1.0: resolution: {integrity: sha512-yvkRyxmFKEOQ4pNXCmJG5AEQNlXJS5LaONXo5/cLdTZdWvsZ1ioJEonLGAosKlMWE8lwUy/bJzMjcw8az73+Fg==} engines: {node: '>=0.10.0'} @@ -6949,8 +7378,8 @@ packages: resolution: {integrity: sha512-kvRdxDsxZjhzUX07ZnLydzS1TU/TJlTUHHY4YLL87e37oUA49DfkLqgy+VjFocowy29cKvcSiu+kIv728jTTVg==} engines: {node: '>= 0.4'} dependencies: - call-bind: 1.0.5 - has-tostringtag: 1.0.0 + call-bind: 1.0.7 + has-tostringtag: 1.0.2 dev: true /is-retry-allowed@1.2.0: @@ -6958,10 +7387,11 @@ packages: engines: {node: '>=0.10.0'} dev: true - /is-shared-array-buffer@1.0.2: - resolution: {integrity: sha512-sqN2UDu1/0y6uvXyStCOzyhAjCSlHceFoMKJW8W9EU9cvic/QdsZ0kEU93HEy3IUEFZIiH/3w+AH/UQbPHNdhA==} + /is-shared-array-buffer@1.0.3: + resolution: {integrity: sha512-nA2hv5XIhLR3uVzDDfCIknerhx8XUKnstuOERPNNIinXG7v9u+ohXF67vxm4TPTEPU6lm61ZkwP3c9PCB97rhg==} + engines: {node: '>= 0.4'} dependencies: - call-bind: 1.0.5 + call-bind: 1.0.7 dev: true /is-ssh@1.4.0: @@ -6989,7 +7419,7 @@ packages: resolution: {integrity: sha512-tE2UXzivje6ofPW7l23cjDOMa09gb7xlAqG6jG5ej6uPV32TlWP3NKPigtaGeHNu9fohccRYvIiZMfOOnOYUtg==} engines: {node: '>= 0.4'} dependencies: - has-tostringtag: 1.0.0 + has-tostringtag: 1.0.2 dev: true /is-symbol@1.0.4: @@ -7006,6 +7436,13 @@ packages: text-extensions: 1.9.0 dev: true + /is-typed-array@1.1.13: + resolution: {integrity: sha512-uZ25/bUAlUY5fR4OKT4rZQEBrzQWYV9ZJYGGsUmEJ6thodVJ1HX64ePQ6Z0qPWP+m+Uq6e9UugrE38jeYsDSMw==} + engines: {node: '>= 0.4'} + dependencies: + which-typed-array: 1.1.15 + dev: true + /is-typedarray@1.0.0: resolution: {integrity: sha512-cyA56iCMHAh5CdzjJIa4aohJyeO1YbwLi3Jc35MmRU6poroFjIGZzUzupGiRPOjgHg9TLu43xbpwXk523fMxKA==} @@ -7021,7 +7458,7 @@ packages: /is-weakref@1.0.2: resolution: {integrity: sha512-qctsuLZmIQ0+vSSMfoVvyFe2+GSEvnmZ2ezTup1SBse9+twCCeial6EEi3Nc2KFcf6+qz2FBPnjXsk8xhKSaPQ==} dependencies: - call-bind: 1.0.5 + call-bind: 1.0.7 dev: true /is-windows@1.0.2: @@ -7046,6 +7483,10 @@ packages: /isarray@1.0.0: resolution: {integrity: sha512-VLghIWNM6ELQzo7zwmcg0NmTVyWKYjvIeM83yjp0wRDTmUnrM678fQbcKBo6n2CJEF0szoG//ytg+TKla89ALQ==} + /isarray@2.0.5: + resolution: {integrity: sha512-xHjhDr3cNBK0BzdUJSPXZntQUx/mwMS5Rw4A7lPJ90XGAO6ISP/ePDNuo0vhqOZU+UD5JoodwCAAoZQd3FeAKw==} + dev: true + /isexe@2.0.0: resolution: {integrity: sha512-RHxMLp9lnKHGHRng9QFhRCMbYAcVpn69smSGcq3f36xjgVVWThj4qqLbTLlq7Ssj8B+fIQ1EuCEGI2lKsyQeIw==} dev: true @@ -7109,7 +7550,7 @@ packages: '@babel/parser': 7.23.6 '@istanbuljs/schema': 0.1.3 istanbul-lib-coverage: 3.2.2 - semver: 7.5.4 + semver: 7.6.0 transitivePeerDependencies: - supports-color dev: true @@ -7788,6 +8229,13 @@ packages: minimist: 1.2.8 dev: true + /json5@1.0.2: + resolution: {integrity: sha512-g1MWMLBiz8FKi1e4w0UyVL3w+iJceWAFBAaBnnGKOpNa5f8TLktkbre1+s6oICydWAm+HRUGTmI+//xv2hvXYA==} + hasBin: true + dependencies: + minimist: 1.2.8 + dev: true + /json5@2.2.3: resolution: {integrity: sha512-XmOWe7eyHYH14cLdVPoyg+GOH3rYX++KpzrylJwSW98t3Nk+U8XOl8FWKOgwtzdb8lXGf6zYwDUzeHMWfxasyg==} engines: {node: '>=6'} @@ -8121,6 +8569,13 @@ packages: p-locate: 4.1.0 dev: true + /locate-path@6.0.0: + resolution: {integrity: sha512-iPZK6eYjbxRu3uB4/WZ3EsEIMJFMqAoopl3R+zuq0UjcAm/MO6KCweDgPfP3elTztoKP3KtnVHxTn2NHBSDVUw==} + engines: {node: '>=10'} + dependencies: + p-locate: 5.0.0 + dev: true + /lodash._reinterpolate@3.0.0: resolution: {integrity: sha512-xYHt68QRoYGjeeM/XOE1uJtvXQAgvszfBhjV4yvsQH0u2i9I6cI6c6/eG4Hh3UAOVn0y/xAXwmTzEay49Q//HA==} dev: true @@ -8281,7 +8736,7 @@ packages: resolution: {integrity: sha512-hXdUTZYIVOt1Ex//jAQi+wTZZpUpwBj/0QsOzqegb3rGMMeJiSEu5xLHnYfBrRV4RH2+OCSOO95Is/7x1WJ4bw==} engines: {node: '>=10'} dependencies: - semver: 7.5.4 + semver: 7.6.0 dev: true /make-error@1.3.6: @@ -8698,6 +9153,12 @@ packages: requiresBuild: true optional: true + /nan@2.19.0: + resolution: {integrity: sha512-nO1xXxfh/RWNxfd/XPfbIfFk5vgLsAxUR9y5O0cHMJu/AW9U95JLXqthYHjEp+8gQ5p96K9jUp8nbVOxCdRbtw==} + requiresBuild: true + dev: true + optional: true + /nanomatch@1.2.13(supports-color@3.2.3): resolution: {integrity: sha512-fpoe2T0RbHwBTBUOftAfBPaDEi06ufaUai0mE6Yn1kacc3SnTErfb/h+X94VXzI64rKFHYImXSvdwGGCmwOqCA==} engines: {node: '>=0.10.0'} @@ -8723,6 +9184,10 @@ packages: dev: true optional: true + /natural-compare-lite@1.4.0: + resolution: {integrity: sha512-Tj+HTDSJJKaZnfiuw+iaF9skdPpTo2GtEly5JHnWV/hfv2Qj/9RKsGISQtLh2ox3l5EAGw487hnBee0sIJ6v2g==} + dev: true + /natural-compare@1.4.0: resolution: {integrity: sha512-OWND8ei3VtNC9h7V60qff3SVobHr996CTwgxubgyQYEpg290h9J0buyECNNJexkFm5sOajh5G116RYA1c8ZMSw==} dev: true @@ -9104,16 +9569,35 @@ packages: isobject: 3.0.1 dev: true - /object.assign@4.1.2: - resolution: {integrity: sha512-ixT2L5THXsApyiUPYKmW+2EHpXXe5Ii3M+f4e+aJFAHao5amFRW6J0OO6c/LU8Be47utCx2GL89hxGB6XSmKuQ==} + /object.assign@4.1.5: + resolution: {integrity: sha512-byy+U7gp+FVwmyzKPYhW2h5l3crpmGsxl7X2s8y43IgxvG4g3QZ6CffDtsNQy1WsmZpQbO+ybo0AlW7TY6DcBQ==} engines: {node: '>= 0.4'} dependencies: - call-bind: 1.0.5 - define-properties: 1.1.4 + call-bind: 1.0.7 + define-properties: 1.2.1 has-symbols: 1.0.3 object-keys: 1.1.1 dev: true + /object.fromentries@2.0.7: + resolution: {integrity: sha512-UPbPHML6sL8PI/mOqPwsH4G6iyXcCGzLin8KvEPenOZN5lpCNBZZQ+V62vdjB1mQHrmqGQt5/OJzemUA+KJmEA==} + engines: {node: '>= 0.4'} + dependencies: + call-bind: 1.0.7 + define-properties: 1.2.1 + es-abstract: 1.22.5 + dev: true + + /object.groupby@1.0.2: + resolution: {integrity: sha512-bzBq58S+x+uo0VjurFT0UktpKHOZmv4/xePiOA1nbB9pMqpGK7rUPNgf+1YC+7mE+0HzhTMqNUuCqvKhj6FnBw==} + dependencies: + array.prototype.filter: 1.0.3 + call-bind: 1.0.7 + define-properties: 1.2.1 + es-abstract: 1.22.5 + es-errors: 1.3.0 + dev: true + /object.omit@2.0.1: resolution: {integrity: sha512-UiAM5mhmIuKLsOvrL+B0U2d1hXHF3bFYWIuH1LMpuV2EJEHG1Ntz06PgLEHjm6VFd87NpH8rastvPoyv6UW2fA==} engines: {node: '>=0.10.0'} @@ -9129,13 +9613,13 @@ packages: isobject: 3.0.1 dev: true - /object.values@1.1.5: - resolution: {integrity: sha512-QUZRW0ilQ3PnPpbNtgdNV1PDbEqLIiSFB3l+EnGtBQ/8SUTLj1PZwtQHABZtLgwpJZTSZhuGLOGk57Drx2IvYg==} + /object.values@1.1.7: + resolution: {integrity: sha512-aU6xnDFYT3x17e/f0IiiwlGPTy2jzMySGfUB4fq6z7CV8l85CWHDk5ErhyhpfDHhrOMwGFhSQkhMGHaIotA6Ng==} engines: {node: '>= 0.4'} dependencies: - call-bind: 1.0.5 - define-properties: 1.1.4 - es-abstract: 1.20.0 + call-bind: 1.0.7 + define-properties: 1.2.1 + es-abstract: 1.22.5 dev: true /once@1.4.0: @@ -9222,16 +9706,16 @@ packages: word-wrap: 1.2.3 dev: false - /optionator@0.9.1: - resolution: {integrity: sha512-74RlY5FCnhq4jRxVUPKDaRwrVNXMqsGsiW6AJw4XK8hmtm10wC0ypZBLw5IIp85NZMr91+qd1RvvENwg7jjRFw==} + /optionator@0.9.3: + resolution: {integrity: sha512-JjCoypp+jKn1ttEFExxhetCKeJt9zhAgAve5FXHixTvFDW/5aEktX9bufBKLRRMdU7bNtpLfcGu94B3cdEJgjg==} engines: {node: '>= 0.8.0'} dependencies: + '@aashutoshrathi/word-wrap': 1.2.6 deep-is: 0.1.4 fast-levenshtein: 2.0.6 levn: 0.4.1 prelude-ls: 1.2.1 type-check: 0.4.0 - word-wrap: 1.2.3 dev: true /ora@5.4.1: @@ -9323,6 +9807,13 @@ packages: p-limit: 2.3.0 dev: true + /p-locate@5.0.0: + resolution: {integrity: sha512-LaNjtRWUBY++zB5nE/NwcaoMylSPk+S+ZHNB1TzdbMJMny6dynpAGt7X/tl/QYq3TIeE6nxHppbo2LGymrG5Pw==} + engines: {node: '>=10'} + dependencies: + p-limit: 3.1.0 + dev: true + /p-map@4.0.0: resolution: {integrity: sha512-/bjOqmgETBYB5BoEeGVea8dmvHb2m9GLy1E9W43yeyfP6QQCZGFNa+XRceJEuDB6zqr+gKpIAmlLebMpykw/MQ==} engines: {node: '>=10'} @@ -9627,6 +10118,11 @@ packages: engines: {node: '>=0.10.0'} dev: true + /possible-typed-array-names@1.0.0: + resolution: {integrity: sha512-d7Uw+eZoloe0EHDIYoe+bQ5WXnGMOpmiZFTuMWCwpjzzkL2nTjcKiAk4hh8TjnGye2TwWOk3UXucZ+3rbmBa8Q==} + engines: {node: '>= 0.4'} + dev: true + /prebuild-install@7.1.1: resolution: {integrity: sha512-jAXscXWMcCK8GgCoHOfIr0ODh5ai8mj63L2nWrjuAgXE6tDyYGnx4/8o/rCgU+B4JSyZBKbeZqzhtwtC3ovxjw==} engines: {node: '>=10'} @@ -10077,18 +10573,14 @@ packages: safe-regex: 1.1.0 dev: true - /regexp.prototype.flags@1.4.3: - resolution: {integrity: sha512-fjggEOO3slI6Wvgjwflkc4NFRCTZAu5CnNfBd5qOMYhWdn67nJBBu34/TkD++eeFmd8C9r9jfXJ27+nSiRkSUA==} + /regexp.prototype.flags@1.5.2: + resolution: {integrity: sha512-NcDiDkTLuPR+++OCKB0nWafEmhg/Da8aUPLPMQbK+bxKKCm1/S5he+AqYa4PlMCVBalb4/yxIRub6qkEx5yJbw==} engines: {node: '>= 0.4'} dependencies: - call-bind: 1.0.5 - define-properties: 1.1.4 - functions-have-names: 1.2.3 - dev: true - - /regexpp@3.2.0: - resolution: {integrity: sha512-pq2bWo9mVD43nbts2wGv17XLiNLya+GklZ8kaDLV2Z08gDCsGpnKn9BFMepvWuHCbyVvY7J5o5+BVvoQbmlJLg==} - engines: {node: '>=8'} + call-bind: 1.0.7 + define-properties: 1.2.1 + es-errors: 1.3.0 + set-function-name: 2.0.2 dev: true /regextras@0.8.0: @@ -10291,6 +10783,16 @@ packages: tslib: 2.4.1 dev: true + /safe-array-concat@1.1.2: + resolution: {integrity: sha512-vj6RsCsWBCf19jIeHEfkRMw8DPiBb+DMXklQ/1SGDHOMlHdPUkZXFQ2YdplS23zESTijAcurb1aSgJA3AgMu1Q==} + engines: {node: '>=0.4'} + dependencies: + call-bind: 1.0.7 + get-intrinsic: 1.2.4 + has-symbols: 1.0.3 + isarray: 2.0.5 + dev: true + /safe-buffer@5.1.2: resolution: {integrity: sha512-Gd2UZBJDkXlY7GbJxfsE8/nvKkUEU1G38c1siN6QP6a9PT9MmHB8GnpscSmMJSoF8LOIrt8ud/wPtojys4G6+g==} @@ -10302,6 +10804,15 @@ packages: requiresBuild: true optional: true + /safe-regex-test@1.0.3: + resolution: {integrity: sha512-CdASjNJPvRa7roO6Ra/gLYBTzYzzPyyBXxIMdGW3USQLyjWEls2RgW5UBTXaQVp+OrpeCK3bLem8smtmheoRuw==} + engines: {node: '>= 0.4'} + dependencies: + call-bind: 1.0.7 + es-errors: 1.3.0 + is-regex: 1.1.4 + dev: true + /safe-regex@1.1.0: resolution: {integrity: sha512-aJXcif4xnaNUzvUuC5gcb46oTS7zvg4jpMTnuqtrEPlR3vFr4pxtdTwaF1Qs3Enjn9HK+ZlwQui+a7z0SywIzg==} dependencies: @@ -10413,6 +10924,14 @@ packages: lru-cache: 6.0.0 dev: true + /semver@7.6.0: + resolution: {integrity: sha512-EnwXhrlwXMk9gKu5/flx5sv/an57AkRplG3hTK68W7FRDN+k+OWBj65M7719OkA82XLBxrcX0KSHj+X5COhOVg==} + engines: {node: '>=10'} + hasBin: true + dependencies: + lru-cache: 6.0.0 + dev: true + /sentence-case@3.0.4: resolution: {integrity: sha512-8LS0JInaQMCRoQ7YUytAo/xUu5W2XnQxV2HI/6uM6U7CITS1RqPElr30V6uIqyMKM9lJGRVFy5/4CuzcixNYSg==} dependencies: @@ -10438,10 +10957,32 @@ packages: resolution: {integrity: sha512-VoaqjbBJKiWtg4yRcKBQ7g7wnGnLV3M8oLvVWwOk2PdYY6PEFegR1vezXR0tw6fZGF9csVakIRjrJiy2veSBFQ==} engines: {node: '>= 0.4'} dependencies: - define-data-property: 1.1.1 + define-data-property: 1.1.4 get-intrinsic: 1.2.2 gopd: 1.0.1 - has-property-descriptors: 1.0.1 + has-property-descriptors: 1.0.2 + dev: true + + /set-function-length@1.2.2: + resolution: {integrity: sha512-pgRc4hJ4/sNjWCSS9AmnS40x3bNMDTknHgL5UaMBTMyJnU90EgWh1Rz+MC9eFu4BuN/UwZjKQuY/1v3rM7HMfg==} + engines: {node: '>= 0.4'} + dependencies: + define-data-property: 1.1.4 + es-errors: 1.3.0 + function-bind: 1.1.2 + get-intrinsic: 1.2.4 + gopd: 1.0.1 + has-property-descriptors: 1.0.2 + dev: true + + /set-function-name@2.0.2: + resolution: {integrity: sha512-7PGFlmtwsEADb0WYyvCMa1t+yke6daIG4Wirafur5kcf+MhUnPms1UeR0CKQdTZD81yESwMHbtn+TR+dMviakQ==} + engines: {node: '>= 0.4'} + dependencies: + define-data-property: 1.1.4 + es-errors: 1.3.0 + functions-have-names: 1.2.3 + has-property-descriptors: 1.0.2 dev: true /set-immediate-shim@1.0.1: @@ -10550,6 +11091,16 @@ packages: object-inspect: 1.13.1 dev: true + /side-channel@1.0.6: + resolution: {integrity: sha512-fDW/EZ6Q9RiO8eFG8Hj+7u/oW+XrPTIChwCOM2+th2A6OblDtYYIpve9m+KvI9Z4C9qSEXlaGR6bTEYHReuglA==} + engines: {node: '>= 0.4'} + dependencies: + call-bind: 1.0.7 + es-errors: 1.3.0 + get-intrinsic: 1.2.4 + object-inspect: 1.13.1 + dev: true + /signal-exit@3.0.7: resolution: {integrity: sha512-wnD2ZE+l+SPC/uoS0vXeE9L1+0wuaMqKlfz9AMUo38JsyLSBWSFcHR1Rri62LZc12vLr1gb3jl7iwQhgwpAbGQ==} @@ -10933,20 +11484,29 @@ packages: strip-ansi: 7.1.0 dev: true - /string.prototype.trimend@1.0.5: - resolution: {integrity: sha512-I7RGvmjV4pJ7O3kdf+LXFpVfdNOxtCW/2C8f6jNiW4+PQchwxkCDzlk1/7p+Wl4bqFIZeF47qAHXLuHHWKAxog==} + /string.prototype.trim@1.2.8: + resolution: {integrity: sha512-lfjY4HcixfQXOfaqCvcBuOIapyaroTXhbkfJN3gcB1OtyupngWK4sEET9Knd0cXd28kTUqu/kHoV4HKSJdnjiQ==} + engines: {node: '>= 0.4'} dependencies: - call-bind: 1.0.5 - define-properties: 1.1.4 - es-abstract: 1.20.0 + call-bind: 1.0.7 + define-properties: 1.2.1 + es-abstract: 1.22.5 dev: true - /string.prototype.trimstart@1.0.5: - resolution: {integrity: sha512-THx16TJCGlsN0o6dl2o6ncWUsdgnLRSA23rRE5pyGBw/mLr3Ej/R2LaqCtgP8VNMGZsvMWnf9ooZPyY2bHvUFg==} + /string.prototype.trimend@1.0.7: + resolution: {integrity: sha512-Ni79DqeB72ZFq1uH/L6zJ+DKZTkOtPIHovb3YZHQViE+HDouuU4mBrLOLDn5Dde3RF8qw5qVETEjhu9locMLvA==} dependencies: - call-bind: 1.0.5 - define-properties: 1.1.4 - es-abstract: 1.20.0 + call-bind: 1.0.7 + define-properties: 1.2.1 + es-abstract: 1.22.5 + dev: true + + /string.prototype.trimstart@1.0.7: + resolution: {integrity: sha512-NGhtDFu3jCEm7B4Fy0DpLewdJQOZcQ0rGbwQ/+stjnrp2i+rlKeCvos9hOIeCmqwratM47OBxY7uFZzjxHXmrg==} + dependencies: + call-bind: 1.0.7 + define-properties: 1.2.1 + es-abstract: 1.22.5 dev: true /string_decoder@0.10.31: @@ -11388,6 +11948,40 @@ packages: yargs-parser: 21.1.1 dev: true + /ts-jest@29.1.1(@babel/core@7.24.0)(jest@29.7.0)(typescript@5.1.6): + resolution: {integrity: sha512-D6xjnnbP17cC85nliwGiL+tpoKN0StpgE0TeOjXQTU6MVCfsB4v7aW05CgQ/1OywGb0x/oy9hHFnN+sczTiRaA==} + engines: {node: ^14.15.0 || ^16.10.0 || >=18.0.0} + hasBin: true + peerDependencies: + '@babel/core': '>=7.0.0-beta.0 <8' + '@jest/types': ^29.0.0 + babel-jest: ^29.0.0 + esbuild: '*' + jest: ^29.0.0 + typescript: 5.1.6 + peerDependenciesMeta: + '@babel/core': + optional: true + '@jest/types': + optional: true + babel-jest: + optional: true + esbuild: + optional: true + dependencies: + '@babel/core': 7.24.0 + bs-logger: 0.2.6 + fast-json-stable-stringify: 2.1.0 + jest: 29.7.0(@types/node@20.4.2)(ts-node@10.7.0) + jest-util: 29.7.0 + json5: 2.2.3 + lodash.memoize: 4.1.2 + make-error: 1.3.6 + semver: 7.5.4 + typescript: 5.1.6(patch_hash=sjs4irdv5ckbkl3gggmzheybku) + yargs-parser: 21.1.1 + dev: true + /ts-loader@9.4.0(typescript@5.1.6)(webpack@5.88.2): resolution: {integrity: sha512-0G3UMhk1bjgsgiwF4rnZRAeTi69j9XMDtmDDMghGSqlWESIAS3LFgJe//GYfE4vcjbyzuURLB9Us2RZIWp2clQ==} engines: {node: '>=12.0.0'} @@ -11460,6 +12054,15 @@ packages: strip-bom: 3.0.0 dev: true + /tsconfig-paths@3.15.0: + resolution: {integrity: sha512-2Ac2RgzDe/cn48GvOe3M+o82pEFewD3UPbyoUHHdKasHwJKjds4fLXWf/Ux5kATBKN20oaFGu+jbElp1pos0mg==} + dependencies: + '@types/json5': 0.0.29 + json5: 1.0.2 + minimist: 1.2.8 + strip-bom: 3.0.0 + dev: true + /tslib@1.14.1: resolution: {integrity: sha512-Xni35NKzjgMrwevysHTCArtLDpPvye8zV/0E4EyYn43P7/7qvQwPh9BGkHewbMulVntbigmcT7rdX3BNo9wRJg==} @@ -11546,6 +12149,50 @@ packages: engines: {node: '>=12.20'} dev: true + /typed-array-buffer@1.0.2: + resolution: {integrity: sha512-gEymJYKZtKXzzBzM4jqa9w6Q1Jjm7x2d+sh19AdsD4wqnMPDYyvwpsIc2Q/835kHuo3BEQ7CjelGhfTsoBb2MQ==} + engines: {node: '>= 0.4'} + dependencies: + call-bind: 1.0.7 + es-errors: 1.3.0 + is-typed-array: 1.1.13 + dev: true + + /typed-array-byte-length@1.0.1: + resolution: {integrity: sha512-3iMJ9q0ao7WE9tWcaYKIptkNBuOIcZCCT0d4MRvuuH88fEoEH62IuQe0OtraD3ebQEoTRk8XCBoknUNc1Y67pw==} + engines: {node: '>= 0.4'} + dependencies: + call-bind: 1.0.7 + for-each: 0.3.3 + gopd: 1.0.1 + has-proto: 1.0.3 + is-typed-array: 1.1.13 + dev: true + + /typed-array-byte-offset@1.0.2: + resolution: {integrity: sha512-Ous0vodHa56FviZucS2E63zkgtgrACj7omjwd/8lTEMEPFFyjfixMZ1ZXenpgCFBBt4EC1J2XsyVS2gkG0eTFA==} + engines: {node: '>= 0.4'} + dependencies: + available-typed-arrays: 1.0.7 + call-bind: 1.0.7 + for-each: 0.3.3 + gopd: 1.0.1 + has-proto: 1.0.3 + is-typed-array: 1.1.13 + dev: true + + /typed-array-length@1.0.5: + resolution: {integrity: sha512-yMi0PlwuznKHxKmcpoOdeLwxBoVPkqZxd7q2FgMkmD3bNwvF5VW0+UlUQ1k1vmktTu4Yu13Q0RIxEP8+B+wloA==} + engines: {node: '>= 0.4'} + dependencies: + call-bind: 1.0.7 + for-each: 0.3.3 + gopd: 1.0.1 + has-proto: 1.0.3 + is-typed-array: 1.1.13 + possible-typed-array-names: 1.0.0 + dev: true + /typed-rest-client@1.8.11: resolution: {integrity: sha512-5UvfMpd1oelmUPRbbaVnq+rHP7ng2cE4qoQkQeAqxRL6PklkxsM0g32/HL0yfvruK6ojQ5x8EE+HF4YV6DtuCA==} dependencies: @@ -11624,7 +12271,7 @@ packages: /unbox-primitive@1.0.2: resolution: {integrity: sha512-61pPlCD9h51VoreyJ0BReideM3MDKMKnh6+V9L08331ipq6Q8OFXZYiqP6n/tbHx4s5I9uRhcye6BrbkizkBDw==} dependencies: - call-bind: 1.0.5 + call-bind: 1.0.7 has-bigints: 1.0.2 has-symbols: 1.0.3 which-boxed-primitive: 1.0.2 @@ -11802,10 +12449,6 @@ packages: resolution: {integrity: sha512-wa7YjyUGfNZngI/vtK0UHAN+lgDCxBPCylVXGp0zu59Fz5aiGtNXaq3DhIov063MorB+VfufLh3JlF2KdTK3xg==} dev: true - /v8-compile-cache@2.3.0: - resolution: {integrity: sha512-l8lCEmLcLYZh4nbunNZvQCJc5pv7+RCwa8q/LdUx8u7lsWvPDKmpodJAJNwkAhJC//dFY48KuIEmjtd4RViDrA==} - dev: true - /v8-to-istanbul@9.2.0: resolution: {integrity: sha512-/EH/sDgxU2eGxajKdwLCDmQ4FWq+kpi3uCmBGpw1xJtnAxEjlD8j8PEiGWpCIMIs3ciNAgH0d3TTJiUkYzyZjA==} engines: {node: '>=10.12.0'} @@ -12178,6 +12821,17 @@ packages: resolution: {integrity: sha512-B+enWhmw6cjfVC7kS8Pj9pCrKSc5txArRyaYGe088shv/FGWH+0Rjx/xPgtsWfsUtS27FkP697E4DDhgrgoc0Q==} dev: true + /which-typed-array@1.1.15: + resolution: {integrity: sha512-oV0jmFtUky6CXfkqehVvBP/LSWJ2sy4vWMioiENyJLePrBO/yKyV9OyJySfAKosh+RYkIl5zJCNZ8/4JncrpdA==} + engines: {node: '>= 0.4'} + dependencies: + available-typed-arrays: 1.0.7 + call-bind: 1.0.7 + for-each: 0.3.3 + gopd: 1.0.1 + has-tostringtag: 1.0.2 + dev: true + /which@1.3.1: resolution: {integrity: sha512-HxJdYWq1MTIQbJ3nw0cqssHoTNU267KlrDuGZ1WYlxDStUtKUhOaJmh112/TZmHxxUfuJqPXSOm7tDyas0OSIQ==} hasBin: true @@ -12225,6 +12879,7 @@ packages: /word-wrap@1.2.3: resolution: {integrity: sha512-Hz/mrNwitNRh/HUAtM/VT/5VH+ygD6DV7mYKZAtHOrbs8U7lvPS6xf7EJKMF0uW1KJCl0H701g3ZGus+muE5vQ==} engines: {node: '>=0.10.0'} + dev: false /wordwrap@0.0.2: resolution: {integrity: sha512-xSBsCeh+g+dinoBv3GAOWM4LcVVO68wLXRanibtBSdUvkGWQRGeE9P7IwU9EmDDi4jA6L44lz15CGMwdw9N5+Q==} diff --git a/tsconfig.json b/tsconfig.json index 28d6f3e9..c311d115 100644 --- a/tsconfig.json +++ b/tsconfig.json @@ -21,7 +21,9 @@ "emitDecoratorMetadata": true, "experimentalDecorators": true, "forceConsistentCasingInFileNames": true, + "skipLibCheck": true, "paths": { + "@vlocode/apex": ["./packages/apex/src"], "@vlocode/core": ["./packages/core/src"], "@vlocode/util": ["./packages/util/src"], "@vlocode/salesforce": ["./packages/salesforce/src"],